wasm-idle 0.3.2 → 0.4.0

package/dist/playground/clang.d.ts

@@ -9,20 +9,23 @@ 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>;
     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,3 +1,4 @@
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 class Clang {
     ts = Date.now();
     output = null;
@@ -6,16 +7,20 @@ 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 = {}) {
         return new Promise(async (resolve) => {
             this.log = log;
-            this.internalBuffer = [];
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -28,19 +33,27 @@ 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) => {
@@ -53,8 +66,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 +77,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 +86,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)
@@ -99,7 +120,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 +132,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];
@@ -16,6 +17,9 @@ export default async function load(language) {
         case 'CPP':
             sandbox = new Clang();
             break;
+        case 'JAVA':
+            sandbox = new Java();
+            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }
@@ -31,6 +35,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,28 @@
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+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;
+    load(path: string, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): 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,135 @@
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { resolveTeaVmBaseUrl } from './teavmConfig';
+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;
+    load(path, _code = '', _log = true, _args = [], _options = {}) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            this.baseUrl = resolveTeaVmBaseUrl(path, typeof window !== 'undefined' ? window.location.href : '');
+            if (!this.worker) {
+                this.worker = new (await import('./worker/java?worker')).default();
+                this.worker.onmessage = (event) => {
+                    if (event.data?.load)
+                        resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({ load: true, baseUrl: this.baseUrl });
+            }
+            else {
+                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 _uid = ++this.uid;
+            this.activeReject = reject;
+            const handler = (event) => {
+                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,
+                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.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;

package/dist/playground/javaStdin.js

@@ -0,0 +1,90 @@
+const JAVA_STDIN_HELPER_CLASS = 'WasmIdleStdin';
+export const prepareJavaStdinInjection = (code, stdin) => {
+    const usesStdin = code.includes('System.in');
+    if (!usesStdin) {
+        return {
+            usesStdin: false,
+            stdinCacheKey: '',
+            transformedCode: code,
+            helperSourcePath: null,
+            helperSource: null
+        };
+    }
+    const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+    const packageName = packageMatch?.[1] || '';
+    const helperSourcePath = packageName
+        ? `${packageName.replaceAll('.', '/')}/${JAVA_STDIN_HELPER_CLASS}.java`
+        : `${JAVA_STDIN_HELPER_CLASS}.java`;
+    const transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    const encodedBytes = [...new TextEncoder().encode(stdin)].join(', ');
+    return {
+        usesStdin: true,
+        stdinCacheKey: stdin,
+        transformedCode,
+        helperSourcePath,
+        helperSource: `${packageName ? `package ${packageName};\n\n` : ''}import java.io.InputStream;
+import org.teavm.jso.JSObject;
+import org.teavm.jso.browser.Window;
+import org.teavm.jso.core.JSFunction;
+import org.teavm.jso.core.JSMapLike;
+
+final class ${JAVA_STDIN_HELPER_CLASS} extends InputStream {
+    private static final byte[] INITIAL_DATA = new byte[] { ${encodedBytes} };
+    private static final ${JAVA_STDIN_HELPER_CLASS} INSTANCE = new ${JAVA_STDIN_HELPER_CLASS}();
+    private int position = 0;
+
+    private ${JAVA_STDIN_HELPER_CLASS}() {
+    }
+
+    static InputStream open() {
+        return INSTANCE;
+    }
+
+    private int readFromHost() {
+        Window current = Window.current();
+        if (current == null) {
+            return -1;
+        }
+        JSMapLike<JSObject> globals = current.cast();
+        JSObject stdin = globals.get("wasmIdleJavaStdin");
+        if (stdin == null) {
+            return -1;
+        }
+        JSFunction readByte = stdin.<JSMapLike<JSObject>>cast().get("readByte").cast();
+        Object value = readByte.call(stdin);
+        return value != null ? Integer.parseInt(value.toString()) : -1;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) {
+        if (b == null) {
+            throw new NullPointerException();
+        }
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len == 0) {
+            return 0;
+        }
+        if (position < INITIAL_DATA.length) {
+            int count = Math.min(len, INITIAL_DATA.length - position);
+            System.arraycopy(INITIAL_DATA, position, b, off, count);
+            position += count;
+            return count;
+        }
+        int next = readFromHost();
+        if (next == -1) {
+            return -1;
+        }
+        b[off] = (byte) next;
+        return 1;
+    }
+
+    @Override
+    public int read() {
+        return position < INITIAL_DATA.length ? INITIAL_DATA[position++] & 0xff : readFromHost();
+    }
+}
+`
+    };
+};

package/dist/playground/options.d.ts

@@ -4,6 +4,15 @@ export interface DebugVariable {
     name: string;
     value: string;
 }
+export type CompilerDiagnosticSeverity = 'error' | 'warning' | 'other';
+export interface CompilerDiagnostic {
+    fileName?: string | null;
+    lineNumber: number;
+    columnNumber?: number;
+    endColumnNumber?: number;
+    severity: CompilerDiagnosticSeverity;
+    message: string;
+}
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
 export interface DebugVariableMetadata {
@@ -36,4 +45,5 @@ export interface SandboxExecutionOptions {
     debug?: boolean;
     breakpoints?: number[];
     pauseOnEntry?: boolean;
+    stdin?: string;
 }

package/dist/playground/python.d.ts

@@ -1,27 +1,37 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import type { Sandbox } from './sandbox';
-import type { SandboxExecutionOptions } from './options';
 declare class Python implements Sandbox {
     ts: number;
     output: any;
+    ondebug?: (event: DebugSessionEvent) => void;
     image?: (data: {
         mime: string;
         b64: string;
         ts?: number;
     }) => void;
-    worker: Worker;
+    worker?: Worker;
     buffer: SharedArrayBuffer;
+    debugBuffer: SharedArrayBuffer;
+    watchBuffer: SharedArrayBuffer;
+    watchResultBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
-    internalBuffer: string[];
+    pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    exit: boolean;
     load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
     write(input: string): 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>;
+    } | import('svelte/store').Writable<number>, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    debugCommand(command: DebugCommand): void;
+    debugEvaluate(expression: string): Promise<string>;
+    kill(): void;
     terminate(): void;
     clear(): Promise<void>;
 }