wasm-idle 0.3.2 → 0.4.1

package/dist/playground/clang.d.ts

@@ -1,7 +1,9 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 import type { Writable } from 'svelte/store';
 declare class Clang implements Sandbox {
+    language: 'C' | 'CPP';
     ts: number;
     output: any;
     ondebug?: (event: DebugSessionEvent) => void;
@@ -9,20 +11,26 @@ declare class Clang implements Sandbox {
     buffer: SharedArrayBuffer;
     debugBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
-    internalBuffer: string[];
+    pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     log: boolean;
+    waitingForInput: boolean;
+    pendingEof: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    constructor(language: 'C' | 'CPP');
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, _progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
-    _write(input: string): void;
     eof(): void;
+    private flushPendingInput;
     run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number> | {
         set?: (value: number) => void;
     }, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
     debugCommand(command: DebugCommand): void;
+    kill(): void;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/clang.js

@@ -1,4 +1,7 @@
+import { resolveSandboxExecutionArgs } from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 class Clang {
+    language;
     ts = Date.now();
     output = null;
     ondebug;
@@ -6,16 +9,24 @@ class Clang {
     buffer = new SharedArrayBuffer(1024);
     debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
     interruptBuffer = new SharedArrayBuffer(1);
-    internalBuffer = [];
+    pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
     log = true;
+    waitingForInput = false;
+    pendingEof = false;
     exit = true;
-    load(path, code = '', log = true, args = [], _options = {}) {
+    constructor(language) {
+        this.language = language;
+    }
+    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, _progress) {
         return new Promise(async (resolve) => {
             this.log = log;
-            this.internalBuffer = [];
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const path = typeof runtimeAssets === 'string' ? runtimeAssets : runtimeAssets?.rootUrl || '';
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -28,24 +39,33 @@ class Clang {
         });
     }
     write(input) {
-        this.internalBuffer.push(input);
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
     }
-    _write(input) {
-        let strInfo = input, padding = 4 - (strInfo.length % 4);
-        while (strInfo.length % 4 !== 3)
-            strInfo += ' ';
-        strInfo += padding;
-        const buffer = new Int32Array(this.buffer);
-        const enc = new TextEncoder();
-        const data = enc.encode(strInfo);
-        buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
     }
-    eof() { }
     run(code, prepare, log = this.log, prog, args = [], options = {}) {
         this.exit = false;
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (!this.worker)
@@ -53,8 +73,10 @@ class Clang {
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
                 const { id, output, results, log, error, buffer, progress, debugEvent } = event.data;
-                if (buffer && this.internalBuffer.length)
-                    this._write(this.internalBuffer.splice(0, 1)[0]);
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
                 if (output)
                     this.output(output);
                 if (debugEvent)
@@ -62,6 +84,8 @@ class Clang {
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -69,6 +93,10 @@ class Clang {
                     console.log(log);
                 if (error) {
                     this.elapse = Date.now() - this.begin;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.exit = true;
+                    this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
                 if (progress)
@@ -85,7 +113,11 @@ class Clang {
                 interrupt: this.interruptBuffer,
                 context: {},
                 log,
-                args,
+                language: this.language,
+                compileArgs,
+                programArgs,
+                cppVersion: options.cppVersion,
+                cVersion: options.cVersion,
                 debug: !!options.debug,
                 breakpoints: [...(options.breakpoints || [])],
                 pauseOnEntry: !!options.pauseOnEntry
@@ -99,7 +131,11 @@ class Clang {
         Atomics.notify(control, 0);
         this.ondebug?.({ type: 'resume', command });
     }
+    kill() {
+        this.terminate();
+    }
     terminate() {
+        this.pendingEof = false;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
@@ -107,11 +143,12 @@ class Clang {
     }
     async clear() {
         this.terminate();
-        this.internalBuffer = [];
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
         if (this.worker)
             this.worker.onmessage = null;
-        const buffer = new Int32Array(this.buffer);
-        buffer.fill(0);
+        resetBufferedStdin(this.buffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));

package/dist/playground/index.d.ts

@@ -1,5 +1,6 @@
 import Clang from './clang';
+import Java from './java';
 import Python from './python';
 import type { Sandbox } from './sandbox';
 export declare const supportedLanguages: string[];
-export default function load(language: string): Promise<Sandbox | Clang | Python>;
+export default function load(language: string): Promise<Sandbox | Clang | Java | Python>;

package/dist/playground/index.js

@@ -1,7 +1,8 @@
 import Clang from './clang';
+import Java from './java';
 import Python from './python';
 const sandboxCache = {};
-export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP'];
+export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA'];
 export default async function load(language) {
     if (sandboxCache[language])
         return sandboxCache[language];
@@ -13,8 +14,13 @@ export default async function load(language) {
             sandbox = new Python();
             break;
         case 'C':
+            sandbox = new Clang('C');
+            break;
         case 'CPP':
-            sandbox = new Clang();
+            sandbox = new Clang('CPP');
+            break;
+        case 'JAVA':
+            sandbox = new Java();
             break;
         default:
             throw new Error(`Unsupported language: ${language}`);
@@ -31,6 +37,8 @@ export default async function load(language) {
             sandboxCache['C'] = sandbox;
         if (language === 'CPP')
             sandboxCache['CPP'] = sandbox;
+        if (language === 'JAVA')
+            sandboxCache['JAVA'] = sandbox;
     }
     return sandbox;
 }

package/dist/playground/java.d.ts

@@ -0,0 +1,33 @@
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { Sandbox } from './sandbox';
+declare class Java implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    baseUrl: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    assetBridge: WorkerAssetBridge | null;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Java;

package/dist/playground/java.js

@@ -0,0 +1,161 @@
+import { resolveSandboxExecutionArgs } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Java {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    baseUrl = '';
+    activeReject = null;
+    oncompilerdiagnostic;
+    waitingForInput = false;
+    pendingEof = false;
+    assetBridge = null;
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const assetConfig = resolveRuntimeAssetConfig('java', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            this.baseUrl = assetConfig.baseUrl;
+            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+                this.assetBridge = null;
+            }
+            if (!this.worker) {
+                this.worker = new (await import('./worker/java?worker')).default();
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'java', assetConfig, progress);
+                this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    if (event.data?.load)
+                        resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
+            }
+            else {
+                if (!this.assetBridge)
+                    return reject('Worker asset bridge unavailable');
+                this.assetBridge.rebind(this.worker, assetConfig, progress);
+                resolve();
+            }
+        });
+    }
+    write(input) {
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
+    }
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
+    }
+    run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        this.exit = false;
+        return new Promise((resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
+            const { programArgs } = resolveSandboxExecutionArgs('JAVA', args, options);
+            const _uid = ++this.uid;
+            this.activeReject = reject;
+            const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (_uid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, results, error, buffer, diagnostic } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (output)
+                    this.output(output);
+                if (diagnostic)
+                    this.oncompilerdiagnostic?.(diagnostic);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    resolve(results);
+                }
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    reject(error);
+                }
+            };
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                buffer: this.buffer,
+                args: programArgs,
+                stdin: options.stdin || '',
+                baseUrl: this.baseUrl
+            });
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.assetBridge = null;
+        this.exit = true;
+    }
+    async clear() {
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        if (this.worker)
+            this.worker.onmessage = null;
+        resetBufferedStdin(this.buffer);
+        if (!this.exit) {
+            this.terminate();
+        }
+    }
+}
+export default Java;

package/dist/playground/javaStdin.d.ts

@@ -0,0 +1,8 @@
+export interface PreparedJavaStdinInjection {
+    usesStdin: boolean;
+    stdinCacheKey: string;
+    transformedCode: string;
+    helperSourcePath: string | null;
+    helperSource: string | null;
+}
+export declare const prepareJavaStdinInjection: (code: string, stdin: string) => PreparedJavaStdinInjection;