wasm-idle 0.2.5 → 0.3.0

package/dist/debug/editor/monaco.js

@@ -0,0 +1,105 @@
+export class MonacoDebugView {
+    Monaco;
+    editor;
+    breakpointDecorations;
+    inlineValueDecorations;
+    pausedLineWidget = null;
+    pausedLineWidgetNode = null;
+    mouseHandler = null;
+    breakpoints = [];
+    onBreakpointsChange;
+    constructor(MonacoModule, editor, onBreakpointsChange) {
+        this.Monaco = MonacoModule;
+        this.editor = editor;
+        this.onBreakpointsChange = onBreakpointsChange;
+        this.breakpointDecorations = editor.createDecorationsCollection();
+        this.inlineValueDecorations = editor.createDecorationsCollection();
+        this.mouseHandler = editor.onMouseDown((event) => {
+            if (event.target.type !== this.Monaco.editor.MouseTargetType.GUTTER_GLYPH_MARGIN &&
+                event.target.type !== this.Monaco.editor.MouseTargetType.GUTTER_LINE_DECORATIONS) {
+                return;
+            }
+            const line = event.target.position?.lineNumber;
+            if (!line)
+                return;
+            const next = this.breakpoints.includes(line)
+                ? this.breakpoints.filter((value) => value !== line)
+                : [...this.breakpoints, line].sort((a, b) => a - b);
+            this.onBreakpointsChange?.(next);
+        });
+    }
+    setBreakpoints(lines) {
+        this.breakpoints = lines;
+        this.breakpointDecorations.set(lines.map((line) => ({
+            range: new this.Monaco.Range(line, 1, line, 1),
+            options: {
+                isWholeLine: false,
+                glyphMarginClassName: 'debug-breakpoint-glyph',
+                glyphMarginHoverMessage: { value: 'Breakpoint' }
+            }
+        })));
+    }
+    setPauseState(pausedLine, locals, adapter) {
+        const lineMaxColumn = pausedLine ? this.editor.getModel()?.getLineMaxColumn(pausedLine) || 1 : 1;
+        if (pausedLine) {
+            const fontInfo = this.editor.getOption(this.Monaco.editor.EditorOption.fontInfo);
+            if (!this.pausedLineWidgetNode) {
+                this.pausedLineWidgetNode = document.createElement('div');
+                this.pausedLineWidgetNode.className = 'debug-paused-line-widget';
+            }
+            this.pausedLineWidgetNode.style.height = `${fontInfo.lineHeight}px`;
+            this.pausedLineWidgetNode.style.width = `${this.editor.getLayoutInfo().contentWidth}px`;
+            if (!this.pausedLineWidget) {
+                this.pausedLineWidget = {
+                    getId: () => 'wasm-idle-debug-current-line',
+                    getDomNode: () => this.pausedLineWidgetNode,
+                    getPosition: () => ({
+                        position: { lineNumber: pausedLine, column: 1 },
+                        preference: [this.Monaco.editor.ContentWidgetPositionPreference.EXACT]
+                    })
+                };
+                this.editor.addContentWidget(this.pausedLineWidget);
+            }
+            else {
+                this.editor.layoutContentWidget(this.pausedLineWidget);
+            }
+            this.editor.revealLineInCenterIfOutsideViewport(pausedLine);
+        }
+        else if (this.pausedLineWidget) {
+            this.editor.removeContentWidget(this.pausedLineWidget);
+            this.pausedLineWidget = null;
+            this.pausedLineWidgetNode = null;
+        }
+        const inlineLocals = pausedLine && adapter
+            ? adapter.selectInlineLocals(this.editor.getModel()?.getLineContent(pausedLine) || '', locals)
+            : [];
+        this.inlineValueDecorations.set(pausedLine && inlineLocals.length
+            ? [
+                {
+                    range: new this.Monaco.Range(pausedLine, lineMaxColumn, pausedLine, lineMaxColumn),
+                    options: {
+                        showIfCollapsed: true,
+                        after: {
+                            content: `  ${inlineLocals
+                                .map((variable) => `${variable.name} = ${variable.value}`)
+                                .join(', ')}`,
+                            inlineClassName: 'debug-inline-values',
+                            inlineClassNameAffectsLetterSpacing: true
+                        },
+                        zIndex: 20
+                    }
+                }
+            ]
+            : []);
+    }
+    dispose() {
+        this.breakpointDecorations.clear();
+        this.inlineValueDecorations.clear();
+        if (this.pausedLineWidget)
+            this.editor.removeContentWidget(this.pausedLineWidget);
+        this.pausedLineWidget = null;
+        this.pausedLineWidgetNode = null;
+        this.mouseHandler?.dispose();
+        this.mouseHandler = null;
+    }
+}

package/dist/debug/expression.d.ts

@@ -0,0 +1,2 @@
+import type { DebugVariable } from '../playground/options';
+export declare function evaluateDebugExpression(expression: string, variables: DebugVariable[]): string;

package/dist/debug/expression.js

@@ -0,0 +1,182 @@
+const operators = ['&&', '||', '==', '!=', '<=', '>=', '+', '-', '*', '/', '%', '<', '>', '!'];
+export function evaluateDebugExpression(expression, variables) {
+    const source = expression.trim();
+    if (!source)
+        throw new Error('empty expression');
+    const values = new Map();
+    for (const variable of variables)
+        values.set(variable.name, variable.value);
+    const tokens = [];
+    for (let index = 0; index < source.length;) {
+        const character = source[index];
+        if (!character)
+            break;
+        if (/\s/.test(character)) {
+            index += 1;
+            continue;
+        }
+        if (character === '(' || character === ')') {
+            tokens.push({ type: 'paren', value: character });
+            index += 1;
+            continue;
+        }
+        const operator = operators.find((candidate) => source.startsWith(candidate, index));
+        if (operator) {
+            tokens.push({ type: 'operator', value: operator });
+            index += operator.length;
+            continue;
+        }
+        const number = source.slice(index).match(/^\d+(?:\.\d+)?/);
+        if (number?.[0]) {
+            tokens.push({ type: 'number', value: number[0] });
+            index += number[0].length;
+            continue;
+        }
+        const identifier = source.slice(index).match(/^[A-Za-z_]\w*/);
+        if (identifier?.[0]) {
+            if (identifier[0] === 'true' || identifier[0] === 'false') {
+                tokens.push({ type: 'boolean', value: identifier[0] === 'true' });
+            }
+            else {
+                tokens.push({ type: 'identifier', value: identifier[0] });
+            }
+            index += identifier[0].length;
+            continue;
+        }
+        throw new Error(`unsupported token near "${source.slice(index)}"`);
+    }
+    let cursor = 0;
+    const parsePrimary = () => {
+        const token = tokens[cursor];
+        if (!token)
+            throw new Error('unexpected end of expression');
+        if (token.type === 'number') {
+            cursor += 1;
+            return Number(token.value);
+        }
+        if (token.type === 'boolean') {
+            cursor += 1;
+            return token.value;
+        }
+        if (token.type === 'identifier') {
+            cursor += 1;
+            const value = values.get(token.value);
+            if (value == null || value === '?')
+                throw new Error('unavailable');
+            if (value === 'true' || value === 'false')
+                return value === 'true';
+            const parsed = Number(value);
+            if (!Number.isNaN(parsed))
+                return parsed;
+            throw new Error(`unsupported value for ${token.value}`);
+        }
+        if (token.type === 'paren' && token.value === '(') {
+            cursor += 1;
+            const result = parseOr();
+            const closing = tokens[cursor];
+            if (!closing || closing.type !== 'paren' || closing.value !== ')')
+                throw new Error('missing closing parenthesis');
+            cursor += 1;
+            return result;
+        }
+        throw new Error('expected value');
+    };
+    const parseUnary = () => {
+        const token = tokens[cursor];
+        if (token?.type === 'operator' && token.value === '!') {
+            cursor += 1;
+            return !Boolean(parseUnary());
+        }
+        if (token?.type === 'operator' && token.value === '-') {
+            cursor += 1;
+            return -Number(parseUnary());
+        }
+        if (token?.type === 'operator' && token.value === '+') {
+            cursor += 1;
+            return Number(parseUnary());
+        }
+        return parsePrimary();
+    };
+    const parseMul = () => {
+        let left = parseUnary();
+        while (true) {
+            const operator = tokens[cursor];
+            if (operator?.type !== 'operator' || !['*', '/', '%'].includes(operator.value))
+                return left;
+            cursor += 1;
+            const right = parseUnary();
+            if (operator.value === '*')
+                left = Number(left) * Number(right);
+            if (operator.value === '/')
+                left = Number(left) / Number(right);
+            if (operator.value === '%')
+                left = Number(left) % Number(right);
+        }
+    };
+    const parseAdd = () => {
+        let left = parseMul();
+        while (true) {
+            const operator = tokens[cursor];
+            if (operator?.type !== 'operator' || !['+', '-'].includes(operator.value))
+                return left;
+            cursor += 1;
+            const right = parseMul();
+            if (operator.value === '+')
+                left = Number(left) + Number(right);
+            if (operator.value === '-')
+                left = Number(left) - Number(right);
+        }
+    };
+    const parseCompare = () => {
+        let left = parseAdd();
+        while (true) {
+            const operator = tokens[cursor];
+            if (operator?.type !== 'operator' || !['<', '<=', '>', '>='].includes(operator.value))
+                return left;
+            cursor += 1;
+            const right = parseAdd();
+            if (operator.value === '<')
+                left = Number(left) < Number(right);
+            if (operator.value === '<=')
+                left = Number(left) <= Number(right);
+            if (operator.value === '>')
+                left = Number(left) > Number(right);
+            if (operator.value === '>=')
+                left = Number(left) >= Number(right);
+        }
+    };
+    const parseEquality = () => {
+        let left = parseCompare();
+        while (true) {
+            const operator = tokens[cursor];
+            if (operator?.type !== 'operator' || !['==', '!='].includes(operator.value))
+                return left;
+            cursor += 1;
+            const right = parseCompare();
+            if (operator.value === '==')
+                left = left === right;
+            if (operator.value === '!=')
+                left = left !== right;
+        }
+    };
+    const parseAnd = () => {
+        let left = parseEquality();
+        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '&&') {
+            cursor += 1;
+            left = Boolean(left) && Boolean(parseEquality());
+        }
+        return left;
+    };
+    const parseOr = () => {
+        let left = parseAnd();
+        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '||') {
+            cursor += 1;
+            left = Boolean(left) || Boolean(parseAnd());
+        }
+        return left;
+    };
+    const result = parseOr();
+    if (cursor !== tokens.length)
+        throw new Error('unexpected trailing tokens');
+    return `${result}`;
+}

package/dist/debug/index.d.ts

@@ -0,0 +1,5 @@
+export { evaluateDebugExpression } from './expression';
+export { selectInlineDebugLocals } from './locals';
+export { cppDebugLanguageAdapter } from './language';
+export { MonacoDebugView } from './editor';
+export type { DebugLanguageAdapter } from './language';

package/dist/debug/index.js

@@ -0,0 +1,4 @@
+export { evaluateDebugExpression } from './expression';
+export { selectInlineDebugLocals } from './locals';
+export { cppDebugLanguageAdapter } from './language';
+export { MonacoDebugView } from './editor';

package/dist/debug/language/cpp.d.ts

@@ -0,0 +1,2 @@
+import type { DebugLanguageAdapter } from './types';
+export declare const cppDebugLanguageAdapter: DebugLanguageAdapter;

package/dist/debug/language/cpp.js

@@ -0,0 +1,7 @@
+import { evaluateDebugExpression } from '../expression';
+import { selectInlineDebugLocals } from '../locals';
+export const cppDebugLanguageAdapter = {
+    id: 'cpp',
+    evaluateExpression: evaluateDebugExpression,
+    selectInlineLocals: selectInlineDebugLocals
+};

package/dist/debug/language/index.d.ts

@@ -0,0 +1,2 @@
+export { cppDebugLanguageAdapter } from './cpp';
+export type { DebugLanguageAdapter } from './types';

package/dist/debug/language/index.js

@@ -0,0 +1 @@
+export { cppDebugLanguageAdapter } from './cpp';

package/dist/debug/language/types.d.ts

@@ -0,0 +1,6 @@
+import type { DebugVariable } from '../../playground/options';
+export interface DebugLanguageAdapter {
+    id: string;
+    evaluateExpression: (expression: string, locals: DebugVariable[]) => string;
+    selectInlineLocals: (lineText: string, locals: DebugVariable[]) => DebugVariable[];
+}

package/dist/debug/language/types.js

@@ -0,0 +1 @@
+export {};

package/dist/debug/locals.d.ts

@@ -0,0 +1,2 @@
+import type { DebugVariable } from '../playground/options';
+export declare function selectInlineDebugLocals(lineText: string, locals: DebugVariable[]): DebugVariable[];

package/dist/debug/locals.js

@@ -0,0 +1,8 @@
+export function selectInlineDebugLocals(lineText, locals) {
+    const sanitized = lineText
+        .replace(/\/\/.*$/g, ' ')
+        .replace(/"(?:\\.|[^"\\])*"/g, ' ')
+        .replace(/'(?:\\.|[^'\\])*'/g, ' ');
+    const identifiers = new Set(sanitized.match(/[A-Za-z_]\w*/g) || []);
+    return locals.filter((variable) => identifiers.has(variable.name));
+}

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import Terminal from './terminal';
+export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };
+export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
+export type { DebugLanguageAdapter } from './debug';

package/dist/index.js

@@ -1,4 +1,5 @@
 import Terminal from './terminal';
+export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };

package/dist/playground/clang.d.ts

@@ -1,10 +1,13 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import type { Sandbox } from './sandbox';
 import type { Writable } from 'svelte/store';
 declare class Clang implements Sandbox {
     ts: number;
     output: any;
+    ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
     buffer: SharedArrayBuffer;
+    debugBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
     internalBuffer: string[];
     begin: number;
@@ -12,11 +15,14 @@ declare class Clang implements Sandbox {
     uid: number;
     log: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, args?: never[]): Promise<void>;
+    load(path: string, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
     write(input: string): void;
     _write(input: string): void;
     eof(): void;
-    run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number>, args?: never[]): Promise<string>;
+    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;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/clang.js

@@ -1,8 +1,10 @@
 class Clang {
     ts = Date.now();
     output = null;
+    ondebug;
     worker = null;
     buffer = new SharedArrayBuffer(1024);
+    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
     interruptBuffer = new SharedArrayBuffer(1);
     internalBuffer = [];
     begin = 0;
@@ -10,7 +12,7 @@ class Clang {
     uid = 0;
     log = true;
     exit = true;
-    load(path, code = '', log = true, args = []) {
+    load(path, code = '', log = true, args = [], _options = {}) {
         return new Promise(async (resolve) => {
             this.log = log;
             this.internalBuffer = [];
@@ -39,7 +41,7 @@ class Clang {
         buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
     }
     eof() { }
-    run(code, prepare, log = this.log, prog, args = []) {
+    run(code, prepare, log = this.log, prog, args = [], options = {}) {
         this.exit = false;
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
@@ -50,14 +52,17 @@ class Clang {
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
-                const { id, output, results, log, error, buffer, progress } = event.data;
+                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 (output)
                     this.output(output);
+                if (debugEvent)
+                    this.ondebug?.(debugEvent);
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
+                    this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
                 if (log)
@@ -76,15 +81,29 @@ class Clang {
                 code,
                 prepare,
                 buffer: this.buffer,
+                debugBuffer: this.debugBuffer,
                 interrupt: this.interruptBuffer,
                 context: {},
                 log,
-                args
+                args,
+                debug: !!options.debug,
+                breakpoints: [...(options.breakpoints || [])],
+                pauseOnEntry: !!options.pauseOnEntry
             });
         });
     }
+    debugCommand(command) {
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, command === 'stepInto' ? 2 : command === 'nextLine' ? 3 : command === 'stepOut' ? 4 : 1);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.ondebug?.({ type: 'resume', command });
+    }
     terminate() {
         new Uint8Array(this.interruptBuffer)[0] = 2;
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
     }
     async clear() {
         this.terminate();
@@ -93,6 +112,8 @@ class Clang {
             this.worker.onmessage = null;
         const buffer = new Int32Array(this.buffer);
         buffer.fill(0);
+        const debugBuffer = new Int32Array(this.debugBuffer);
+        debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));
         if (!this.exit) {
             this.worker?.terminate?.();

package/dist/playground/options.d.ts

@@ -0,0 +1,38 @@
+export type DebugCommand = 'continue' | 'stepInto' | 'nextLine' | 'stepOut';
+export type DebugPauseReason = 'breakpoint' | 'entry' | 'step' | 'nextLine' | 'stepOut';
+export interface DebugVariable {
+    name: string;
+    value: string;
+}
+export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
+export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
+export interface DebugVariableMetadata {
+    slot: number;
+    name: string;
+    kind: DebugVariableKind;
+    fromLine: number;
+    toLine: number;
+    elementKind?: DebugArrayElementKind;
+    length?: number;
+}
+export interface DebugFrame {
+    functionName: string;
+    line: number;
+}
+export type DebugSessionEvent = {
+    type: 'pause';
+    line: number;
+    reason: DebugPauseReason;
+    locals: DebugVariable[];
+    callStack: DebugFrame[];
+} | {
+    type: 'resume';
+    command: DebugCommand;
+} | {
+    type: 'stop';
+};
+export interface SandboxExecutionOptions {
+    debug?: boolean;
+    breakpoints?: number[];
+    pauseOnEntry?: boolean;
+}

package/dist/playground/options.js

@@ -0,0 +1 @@
+export {};

package/dist/playground/python.d.ts

@@ -1,7 +1,13 @@
 import type { Sandbox } from './sandbox';
+import type { SandboxExecutionOptions } from './options';
 declare class Python implements Sandbox {
     ts: number;
     output: any;
+    image?: (data: {
+        mime: string;
+        b64: string;
+        ts?: number;
+    }) => void;
     worker: Worker;
     buffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
@@ -9,11 +15,13 @@ declare class Python implements Sandbox {
     begin: number;
     elapse: number;
     uid: number;
-    load(path: string, code?: string, log?: boolean): Promise<void>;
+    load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
     write(input: string): void;
     _write(input: string): void;
     eof(): void;
-    run(code: string, prepare: boolean): Promise<string>;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>, _args?: string[], _options?: SandboxExecutionOptions): Promise<boolean | string>;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/python.js

@@ -1,6 +1,7 @@
 class Python {
     ts = Date.now();
     output = null;
+    image;
     worker = null;
     buffer = new SharedArrayBuffer(1024);
     interruptBuffer = new SharedArrayBuffer(1);
@@ -8,7 +9,7 @@ class Python {
     begin = 0;
     elapse = 0;
     uid = 0;
-    load(path, code = '', log = true) {
+    load(path, code = '', log = true, _args = [], _options = {}) {
         return new Promise(async (resolve) => {
             this.internalBuffer = [];
             if (!this.worker) {
@@ -36,15 +37,17 @@ class Python {
         buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
     }
     eof() { }
-    run(code, prepare) {
+    run(code, prepare, _log = true, _prog, _args = [], _options = {}) {
         return new Promise(async (resolve, reject) => {
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
-                const { id, output, results, log, error, buffer } = event.data;
+                const { id, output, results, log, error, buffer, type, data: payload } = event.data;
                 if (buffer && this.internalBuffer.length)
                     this._write(this.internalBuffer.splice(0, 1)[0]);
+                if (type === 'img' && payload)
+                    this.image?.(payload);
                 if (output)
                     this.output(output);
                 if (results) {

package/dist/playground/sandbox.d.ts

@@ -1,12 +1,25 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { Writable } from 'svelte/store';
+type ProgressLike = Writable<number> | {
+    set?: (value: number) => void;
+};
 export interface Sandbox {
     constructor: any;
     eof: () => void;
-    load: (path: string, code?: string, log?: boolean) => Promise<void>;
-    run: (code: string, prepare: boolean, log?: boolean) => Promise<string>;
+    load: (path: string, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions) => Promise<void>;
+    run: (code: string, prepare: boolean, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     terminate: () => void;
     clear: () => Promise<void>;
     kill?: () => void;
     write?: (data: string) => void;
     output?: (data: string) => void;
+    ondebug?: (event: DebugSessionEvent) => void;
+    debugCommand?: (command: DebugCommand) => void;
+    image?: (data: {
+        mime: string;
+        b64: string;
+        ts?: number;
+    }) => void;
     elapse?: number;
 }
+export {};