@tybys/wasm-util 0.4.0 → 0.5.0

package/lib/mjs/asyncify.mjs

@@ -90,18 +90,20 @@ export class Asyncify {
         }
     }
     wrapImportFunction(f) {
-        return ((...args) => {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        return (function () {
             // eslint-disable-next-line no-unreachable-loop
-            while (this.exports.asyncify_get_state() === AsyncifyState.REWINDING) {
-                this.exports.asyncify_stop_rewind();
-                return this.value;
+            while (_this.exports.asyncify_get_state() === AsyncifyState.REWINDING) {
+                _this.exports.asyncify_stop_rewind();
+                return _this.value;
             }
-            this.assertState();
-            const v = f(...args);
+            _this.assertState();
+            const v = f.apply(this, arguments);
             if (!isPromiseLike(v))
                 return v;
-            this.exports.asyncify_start_unwind(this.dataPtr);
-            this.value = v;
+            _this.exports.asyncify_start_unwind(_this.dataPtr);
+            _this.value = v;
         });
     }
     wrapImports(imports) {
@@ -123,17 +125,19 @@ export class Asyncify {
         return importObject;
     }
     wrapExportFunction(f) {
-        return (async (...args) => {
-            this.assertState();
-            let ret = f(...args);
-            while (this.exports.asyncify_get_state() === AsyncifyState.UNWINDING) {
-                this.exports.asyncify_stop_unwind();
-                this.value = await this.value;
-                this.assertState();
-                this.exports.asyncify_start_rewind(this.dataPtr);
-                ret = f();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        return (async function () {
+            _this.assertState();
+            let ret = f.apply(this, arguments);
+            while (_this.exports.asyncify_get_state() === AsyncifyState.UNWINDING) {
+                _this.exports.asyncify_stop_unwind();
+                _this.value = await _this.value;
+                _this.assertState();
+                _this.exports.asyncify_start_rewind(_this.dataPtr);
+                ret = f.call(this);
             }
-            this.assertState();
+            _this.assertState();
             return ret;
         });
     }

package/lib/mjs/load.mjs

@@ -1,5 +1,10 @@
 import { _WebAssembly } from "./webassembly.mjs";
 import { Asyncify } from "./asyncify.mjs";
+function validateImports(imports) {
+    if (imports && typeof imports !== 'object') {
+        throw new TypeError('imports must be an object or undefined');
+    }
+}
 async function fetchWasm(urlOrBuffer, imports) {
     if (typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {
         return await _WebAssembly.instantiate(urlOrBuffer, imports);
@@ -10,24 +15,12 @@ async function fetchWasm(urlOrBuffer, imports) {
     return source;
 }
 /** @public */
-export async function load(urlOrBuffer, imports, asyncify) {
-    var _a, _b;
-    if (imports && typeof imports !== 'object') {
-        throw new TypeError('imports must be an object or undefined');
-    }
+export async function load(urlOrBuffer, imports) {
+    validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    let asyncifyHelper;
     let source;
-    if (asyncify) {
-        asyncifyHelper = new Asyncify();
-        imports = asyncifyHelper.wrapImports(imports);
-    }
     if (urlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(urlOrBuffer)) {
         source = await _WebAssembly.instantiate(urlOrBuffer, imports);
-        if (asyncify) {
-            const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-            return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-        }
         return source;
     }
     if (typeof urlOrBuffer !== 'string' && !(urlOrBuffer instanceof URL)) {
@@ -44,33 +37,39 @@ export async function load(urlOrBuffer, imports, asyncify) {
     else {
         source = await fetchWasm(urlOrBuffer, imports);
     }
-    if (asyncify) {
-        const memory = source.instance.exports.memory || ((_b = imports.env) === null || _b === void 0 ? void 0 : _b.memory);
-        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-    }
     return source;
 }
 /** @public */
-export function loadSync(buffer, imports, asyncify) {
+export async function asyncifyLoad(asyncify, urlOrBuffer, imports) {
     var _a;
+    validateImports(imports);
+    imports = imports !== null && imports !== void 0 ? imports : {};
+    const asyncifyHelper = new Asyncify();
+    imports = asyncifyHelper.wrapImports(imports);
+    const source = await load(urlOrBuffer, imports);
+    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
+}
+/** @public */
+export function loadSync(buffer, imports) {
     if ((buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
         throw new TypeError('Invalid source');
     }
-    if (imports && typeof imports !== 'object') {
-        throw new TypeError('imports must be an object or undefined');
-    }
+    validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    let asyncifyHelper;
-    if (asyncify) {
-        asyncifyHelper = new Asyncify();
-        imports = asyncifyHelper.wrapImports(imports);
-    }
     const module = new _WebAssembly.Module(buffer);
     const instance = new _WebAssembly.Instance(module, imports);
     const source = { instance, module };
-    if (asyncify) {
-        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-        return { module: source.module, instance: asyncifyHelper.init(memory, instance, asyncify) };
-    }
     return source;
 }
+/** @public */
+export function asyncifyLoadSync(asyncify, buffer, imports) {
+    var _a;
+    validateImports(imports);
+    imports = imports !== null && imports !== void 0 ? imports : {};
+    const asyncifyHelper = new Asyncify();
+    imports = asyncifyHelper.wrapImports(imports);
+    const source = loadSync(buffer, imports);
+    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
+}

package/lib/mjs/wasi/fd.mjs

@@ -112,7 +112,6 @@ export class FileDescriptorTable {
         this.size = options.size;
         this.fds = Array(options.size);
         this.stdio = [options.in, options.out, options.err];
-        this.fs = options.fs;
         this.print = options.print;
         this.printErr = options.printErr;
         this.insertStdio(options.in, 0, '<stdin>');
@@ -159,18 +158,6 @@ export class FileDescriptorTable {
         this.used++;
         return entry;
     }
-    getFileTypeByFd(fd) {
-        const stat = this.fs.fstatSync(fd);
-        return toFileType(stat);
-    }
-    insertPreopen(fd, mappedPath, realPath) {
-        const type = this.getFileTypeByFd(fd);
-        if (type !== WasiFileType.DIRECTORY) {
-            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
-        }
-        const result = getRights(this.stdio, fd, 0, type);
-        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
-    }
     get(id, base, inheriting) {
         if (id >= this.size) {
             throw new WasiError('Invalid fd', WasiErrno.EBADF);
@@ -196,6 +183,24 @@ export class FileDescriptorTable {
         this.fds[id] = undefined;
         this.used--;
     }
+}
+export class SyncTable extends FileDescriptorTable {
+    constructor(options) {
+        super(options);
+        this.fs = options.fs;
+    }
+    getFileTypeByFd(fd) {
+        const stats = this.fs.fstatSync(fd, { bigint: true });
+        return toFileType(stats);
+    }
+    insertPreopen(fd, mappedPath, realPath) {
+        const type = this.getFileTypeByFd(fd);
+        if (type !== WasiFileType.DIRECTORY) {
+            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
+        }
+        const result = getRights(this.stdio, fd, 0, type);
+        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+    }
     renumber(dst, src) {
         if (dst === src)
             return;
@@ -214,3 +219,38 @@ export class FileDescriptorTable {
         this.used--;
     }
 }
+export class AsyncTable extends FileDescriptorTable {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(options) {
+        super(options);
+    }
+    async getFileTypeByFd(fd) {
+        const stats = await fd.stat({ bigint: true });
+        return toFileType(stats);
+    }
+    async insertPreopen(fd, mappedPath, realPath) {
+        const type = await this.getFileTypeByFd(fd);
+        if (type !== WasiFileType.DIRECTORY) {
+            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
+        }
+        const result = getRights(this.stdio, fd.fd, 0, type);
+        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+    }
+    async renumber(dst, src) {
+        if (dst === src)
+            return;
+        if (dst >= this.size || src >= this.size) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        const dstEntry = this.fds[dst];
+        const srcEntry = this.fds[src];
+        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        await dstEntry.fd.close();
+        this.fds[dst] = this.fds[src];
+        this.fds[dst].id = dst;
+        this.fds[src] = undefined;
+        this.used--;
+    }
+}

package/lib/mjs/wasi/index.mjs

@@ -1,5 +1,5 @@
 import { WASI as _WASI } from "./preview1.mjs";
-import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined, validateString } from "./util.mjs";
+import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined } from "./util.mjs";
 const kEmptyObject = Object.freeze(Object.create(null));
 const kExitCode = Symbol('kExitCode');
 const kSetMemory = Symbol('kSetMemory');
@@ -13,74 +13,105 @@ function setupInstance(self, instance) {
 }
 // /** @public */
 // export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
-/** @public */
-export class WASI {
-    constructor(options = kEmptyObject) {
-        var _a;
-        validateObject(options, 'options');
-        if (options.args !== undefined) {
-            validateArray(options.args, 'options.args');
-        }
-        const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
-        const env = [];
-        if (options.env !== undefined) {
-            validateObject(options.env, 'options.env');
-            Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
-                if (value !== undefined) {
-                    env.push(`${key}=${value}`);
-                }
-            });
-        }
-        const preopens = [];
-        if (options.preopens !== undefined) {
-            validateObject(options.preopens, 'options.preopens');
-            Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
-        }
-        if (preopens.length > 0) {
-            if (options.filesystem === undefined) {
-                throw new Error('filesystem is disabled, can not preopen directory');
+function validateOptions(options) {
+    var _a;
+    validateObject(options, 'options');
+    if (options.args !== undefined) {
+        validateArray(options.args, 'options.args');
+    }
+    const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
+    const env = [];
+    if (options.env !== undefined) {
+        validateObject(options.env, 'options.env');
+        Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
+            if (value !== undefined) {
+                env.push(`${key}=${value}`);
             }
+        });
+    }
+    const preopens = [];
+    if (options.preopens !== undefined) {
+        validateObject(options.preopens, 'options.preopens');
+        Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
+    }
+    if (preopens.length > 0) {
+        if (options.fs === undefined) {
+            throw new Error('filesystem is disabled, can not preopen directory');
         }
-        if (options.filesystem !== undefined) {
-            validateObject(options.filesystem, 'options.filesystem');
-            validateString(options.filesystem.type, 'options.filesystem.type');
-            if (options.filesystem.type !== 'memfs') {
-                throw new Error(`Filesystem type ${options.filesystem.type} is not supported, only "memfs" is supported currently`);
-            }
-            try {
-                validateObject(options.filesystem.fs, 'options.filesystem.fs');
-            }
-            catch (_) {
-                throw new Error('Node.js fs like implementation is not provided');
-            }
+        try {
+            validateObject(options.fs, 'options.fs');
         }
-        if (options.print !== undefined)
-            validateFunction(options.print, 'options.print');
-        if (options.printErr !== undefined)
-            validateFunction(options.printErr, 'options.printErr');
-        // const { stdin = 0, stdout = 1, stderr = 2 } = options
-        // validateInt32(stdin, 'options.stdin', 0)
-        // validateInt32(stdout, 'options.stdout', 0)
-        // validateInt32(stderr, 'options.stderr', 0)
-        // const stdio = [stdin, stdout, stderr] as const
-        const stdio = [0, 1, 2];
-        const wrap = new _WASI(args, env, preopens, stdio, options.filesystem, options.print, options.printErr);
-        for (const prop in wrap) {
-            wrap[prop] = wrap[prop].bind(wrap);
+        catch (_) {
+            throw new TypeError('Node.js fs like implementation is not provided');
         }
-        if (options.returnOnExit !== undefined) {
-            validateBoolean(options.returnOnExit, 'options.returnOnExit');
-            if (options.returnOnExit) {
-                wrap.proc_exit = wasiReturnOnProcExit.bind(this);
-            }
-        }
-        this[kSetMemory] = wrap._setMemory;
-        delete wrap._setMemory;
+    }
+    // if (options.filesystem !== undefined) {
+    //   validateObject(options.filesystem, 'options.filesystem')
+    //   validateString(options.filesystem.type, 'options.filesystem.type')
+    //   if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') {
+    //     throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only "memfs" and "file-system-access-api" is supported currently`)
+    //   }
+    //   try {
+    //     validateObject(options.filesystem.fs, 'options.filesystem.fs')
+    //   } catch (_) {
+    //     throw new Error('Node.js fs like implementation is not provided')
+    //   }
+    // }
+    if (options.print !== undefined)
+        validateFunction(options.print, 'options.print');
+    if (options.printErr !== undefined)
+        validateFunction(options.printErr, 'options.printErr');
+    if (options.returnOnExit !== undefined) {
+        validateBoolean(options.returnOnExit, 'options.returnOnExit');
+    }
+    // const { stdin = 0, stdout = 1, stderr = 2 } = options
+    // validateInt32(stdin, 'options.stdin', 0)
+    // validateInt32(stdout, 'options.stdout', 0)
+    // validateInt32(stderr, 'options.stderr', 0)
+    // const stdio = [stdin, stdout, stderr] as const
+    const stdio = [0, 1, 2];
+    return {
+        args,
+        env,
+        preopens,
+        stdio
+    };
+}
+/** @public */
+export class WASI {
+    constructor(setMemory, wrap) {
+        this[kSetMemory] = setMemory;
         this.wasiImport = wrap;
         this[kStarted] = false;
         this[kExitCode] = 0;
         this[kInstance] = undefined;
     }
+    static createSync(options = kEmptyObject) {
+        const { args, env, preopens, stdio } = validateOptions(options);
+        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
+        const setMemory = wrap._setMemory;
+        delete wrap._setMemory;
+        const _this = new WASI(setMemory, wrap);
+        if (options.returnOnExit) {
+            wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+        }
+        return _this;
+    }
+    static async createAsync(options = kEmptyObject) {
+        const { args, env, preopens, stdio } = validateOptions(options);
+        if (options.asyncify !== undefined) {
+            validateObject(options.asyncify, 'options.asyncify');
+            validateFunction(options.asyncify.wrapImportFunction, 'options.asyncify.wrapImportFunction');
+        }
+        const wrap = await _WASI.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
+        const setMemory = wrap._setMemory;
+        delete wrap._setMemory;
+        const _this = new WASI(setMemory, wrap);
+        if (options.returnOnExit) {
+            wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+        }
+        return _this;
+    }
     // Must not export _initialize, must export _start
     start(instance) {
         if (this[kStarted]) {