wasm-idle 0.2.3 → 0.2.5

package/dist/clang/index.d.ts

@@ -33,7 +33,11 @@ export default class Clang {
     compile(options: any): Promise<App | null>;
     link(obj: string, wasm: string): Promise<App | null>;
     run(module: WebAssembly.Module, out: boolean, ...args: string[]): Promise<App | null>;
-    compileLink(code: string): Promise<any>;
-    compileLinkRun(code: string): Promise<App | null>;
+    compileLink(code: string, { args }?: {
+        args?: never[] | undefined;
+    }): Promise<any>;
+    compileLinkRun(code: string, { args }?: {
+        args?: never[] | undefined;
+    }): Promise<App | null>;
 }
 export {};

package/dist/clang/index.js

@@ -108,7 +108,7 @@ export default class Clang {
         await this.ready;
         this.memfs.addFile(input, code);
         const clang = await this.getModule(clangUrl(this.path));
-        return await this.run(clang, true, 'clang', '-cc1', '-emit-obj', ...clangCommonArgs, '-O' + opt, '-o', obj, '-std=c++17', '-x', 'c++', input);
+        return await this.run(clang, true, 'clang', '-cc1', '-emit-obj', ...clangCommonArgs, '-O' + opt, '-o', obj, '-std=c++17', '-x', 'c++', input, ...(options.args || []));
     }
     async link(obj, wasm) {
         const stackSize = 1024 * 1024;
@@ -133,16 +133,16 @@ export default class Clang {
             this.stdout(`${green}(${start - instantiate}ms/${end - instantiate}ms)${normal}\n`);
         return stillRunning ? app : null;
     }
-    async compileLink(code) {
+    async compileLink(code, { args = [] } = {}) {
         const input = `test.cc`, obj = `test.o`, wasm = `test.wasm`;
         if (this.lastCode === code)
             return this.wasm;
-        await this.compile({ input, code, obj });
+        await this.compile({ input, code, obj, args });
         await this.link(obj, wasm);
         this.lastCode = code;
         return (this.wasm = await this.hostLogAsync(`Compiling ${wasm}`, WebAssembly.compile(this.memfs.getFileContents(wasm))));
     }
-    async compileLinkRun(code) {
-        return await this.run(await this.compileLink(code), true, `test.wasm`);
+    async compileLinkRun(code, { args = [] } = {}) {
+        return await this.run(await this.compileLink(code, { args }), true, `test.wasm`);
     }
 }

package/dist/playground/clang.d.ts

@@ -12,11 +12,11 @@ declare class Clang implements Sandbox {
     uid: number;
     log: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean): Promise<void>;
+    load(path: string, code?: string, log?: boolean, args?: never[]): Promise<void>;
     write(input: string): void;
     _write(input: string): void;
     eof(): void;
-    run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number>): Promise<string>;
+    run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number>, args?: never[]): Promise<string>;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/clang.js

@@ -10,14 +10,14 @@ class Clang {
     uid = 0;
     log = true;
     exit = true;
-    load(path, code = '', log = true) {
+    load(path, code = '', log = true, args = []) {
         return new Promise(async (resolve) => {
             this.log = log;
             this.internalBuffer = [];
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
-                this.worker.postMessage({ load: true, path, log, code });
+                this.worker.postMessage({ load: true, path, log, code, args });
             }
             else {
                 this.worker.postMessage({ log });
@@ -39,7 +39,7 @@ class Clang {
         buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
     }
     eof() { }
-    run(code, prepare, log = this.log, prog) {
+    run(code, prepare, log = this.log, prog, args = []) {
         this.exit = false;
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
@@ -78,7 +78,8 @@ class Clang {
                 buffer: this.buffer,
                 interrupt: this.interruptBuffer,
                 context: {},
-                log
+                log,
+                args
             });
         });
     }

package/dist/playground/worker/clang.js

@@ -33,7 +33,7 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, load, interrupt, log, path, prepare } = event.data;
+    const { code, buffer, load, interrupt, log, path, prepare, args } = event.data;
     if (load) {
         await loadClang(path, log);
         postMessage({ load: true });
@@ -42,7 +42,7 @@ self.onmessage = async (event) => {
         stdinBufferClang = new Int32Array(buffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
-            await clang.compileLink(code);
+            await clang.compileLink(code, { args });
             self.postMessage({ results: true });
         }
         catch (error) {
@@ -54,7 +54,7 @@ self.onmessage = async (event) => {
         stdinBufferClang = new Int32Array(buffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
-            await clang.compileLinkRun(code);
+            await clang.compileLinkRun(code, { args });
             self.postMessage({ results: true });
         }
         catch (error) {

package/dist/terminal/Terminal.svelte

@@ -103,19 +103,19 @@
 			first = true;
 			await new Promise((r) => setTimeout(r, 100));
 		},
-		async prepare(language: string, code: string, log = true, prog) {
+		async prepare(language: string, code: string, log = true, prog, args) {
 			await Promise.all([
 				initSandbox(language).then(() => sandbox.load(path, code, log)),
 				initTerm(false)
 			]);
-			return await runSandbox(sandbox.run(code, true, log, prog));
+			return await runSandbox(sandbox.run(code, true, log, prog, args));
 		},
-		async run(language: string, code: string, log = true, prog) {
+		async run(language: string, code: string, log = true, prog, args) {
 			await Promise.all([
 				initSandbox(language).then(() => sandbox.load(path, code, log)),
 				initTerm()
 			]);
-			return await runSandbox(sandbox.run(code, false, log, prog));
+			return await runSandbox(sandbox.run(code, false, log, prog, args));
 		},
 		async destroy() {
 			await wait();

package/dist/terminal/Terminal.svelte.d.ts

@@ -8,8 +8,8 @@ declare const Terminal: import("svelte").Component<{
     onkey?: (e: KeyboardEvent) => void;
     terminal?: {
         clear(): Promise<void>;
-        prepare(language: string, code: string, log: boolean | undefined, prog: any): Promise<boolean>;
-        run(language: string, code: string, log: boolean | undefined, prog: any): Promise<boolean>;
+        prepare(language: string, code: string, log: boolean | undefined, prog: any, args: any): Promise<boolean>;
+        run(language: string, code: string, log: boolean | undefined, prog: any, args: any): Promise<boolean>;
         destroy(): Promise<void>;
         write(input: string): Promise<void>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.2.3",
+	"version": "0.2.5",
 	"description": "A simple web app to run C++/Python code in the browser",
 	"license": "MIT",
 	"type": "module",
@@ -69,5 +69,10 @@
 		}
 	},
 	"svelte": "./dist/index.js",
-	"types": "./dist/index.d.ts"
+	"types": "./dist/index.d.ts",
+	"pnpm": {
+		"onlyBuiltDependencies": [
+			"esbuild"
+		]
+	}
 }