wasm-idle 0.4.0 → 0.5.0

package/dist/debug/controller.svelte.js

@@ -0,0 +1,268 @@
+import { fromStore, get, writable } from 'svelte/store';
+export function createDebugSessionController(options = {}) {
+    const activeStore = writable(false);
+    const pausedStore = writable(false);
+    const pausedLineStore = writable(null);
+    const localsStore = writable([]);
+    const callStackStore = writable([]);
+    const runToCursorLineStore = writable(null);
+    const watchInputStore = writable('');
+    const watchExpressionsStore = writable([]);
+    const watchValuesStore = writable([]);
+    const breakpointsStore = writable([...(options.breakpoints || [])]);
+    const cursorLineStore = writable(options.cursorLine ?? null);
+    const terminalStore = writable(options.terminal);
+    const adapterStore = writable(options.adapter ?? null);
+    const activeState = fromStore(activeStore);
+    const pausedState = fromStore(pausedStore);
+    const pausedLineState = fromStore(pausedLineStore);
+    const localsState = fromStore(localsStore);
+    const callStackState = fromStore(callStackStore);
+    const runToCursorLineState = fromStore(runToCursorLineStore);
+    const watchInputState = fromStore(watchInputStore);
+    const watchExpressionsState = fromStore(watchExpressionsStore);
+    const watchValuesState = fromStore(watchValuesStore);
+    const breakpointsState = fromStore(breakpointsStore);
+    const cursorLineState = fromStore(cursorLineStore);
+    const terminalState = fromStore(terminalStore);
+    const adapterState = fromStore(adapterStore);
+    let watchRequestVersion = 0;
+    function shouldSyncBreakpoints() {
+        if (typeof options.syncBreakpointsWhile === 'function') {
+            return options.syncBreakpointsWhile();
+        }
+        if (typeof options.syncBreakpointsWhile === 'boolean') {
+            return options.syncBreakpointsWhile;
+        }
+        return get(activeStore);
+    }
+    function getEffectiveBreakpoints() {
+        const lines = [...get(breakpointsStore)];
+        const runToCursorLine = get(runToCursorLineStore);
+        if (runToCursorLine !== null && !lines.includes(runToCursorLine))
+            lines.push(runToCursorLine);
+        return lines.sort((left, right) => left - right);
+    }
+    function refreshWatchValues() {
+        const expressions = [...get(watchExpressionsStore)];
+        const adapter = get(adapterStore);
+        const localVariables = [...get(localsStore)];
+        const paused = get(pausedStore);
+        const terminal = get(terminalStore);
+        const version = ++watchRequestVersion;
+        if (!expressions.length) {
+            watchValuesStore.set([]);
+            return;
+        }
+        if (paused && terminal?.debugEvaluate) {
+            watchValuesStore.set(expressions.map((expression) => ({ expression, value: '...' })));
+            (async () => {
+                const resolved = [];
+                for (const expression of expressions) {
+                    resolved.push({
+                        expression,
+                        value: await terminal.debugEvaluate(expression)
+                    });
+                }
+                if (version === watchRequestVersion)
+                    watchValuesStore.set(resolved);
+            })().catch(() => {
+                if (version === watchRequestVersion) {
+                    watchValuesStore.set(expressions.map((expression) => ({ expression, value: 'error' })));
+                }
+            });
+            return;
+        }
+        watchValuesStore.set(expressions.map((expression) => {
+            try {
+                return {
+                    expression,
+                    value: adapter ? adapter.evaluateExpression(expression, localVariables) : 'error'
+                };
+            }
+            catch (error) {
+                return {
+                    expression,
+                    value: error instanceof Error && error.message === 'unavailable' ? '?' : 'error'
+                };
+            }
+        }));
+    }
+    function syncBreakpoints() {
+        const terminal = get(terminalStore);
+        if (!shouldSyncBreakpoints() || !terminal?.setBreakpoints)
+            return;
+        void terminal.setBreakpoints(getEffectiveBreakpoints());
+    }
+    function clearPauseState() {
+        runToCursorLineStore.set(null);
+        pausedLineStore.set(null);
+        localsStore.set([]);
+        callStackStore.set([]);
+        pausedStore.set(false);
+    }
+    function reset() {
+        activeStore.set(false);
+        clearPauseState();
+        refreshWatchValues();
+    }
+    function begin() {
+        activeStore.set(true);
+        clearPauseState();
+        refreshWatchValues();
+        syncBreakpoints();
+    }
+    function handleEvent(event) {
+        if (event.type === 'pause') {
+            activeStore.set(true);
+            runToCursorLineStore.set(null);
+            pausedLineStore.set(event.line);
+            localsStore.set(event.locals);
+            callStackStore.set(event.callStack);
+            pausedStore.set(true);
+            refreshWatchValues();
+            return;
+        }
+        if (event.type === 'resume') {
+            pausedStore.set(false);
+            pausedLineStore.set(null);
+            localsStore.set([]);
+            callStackStore.set([]);
+            refreshWatchValues();
+            return;
+        }
+        reset();
+    }
+    function setTerminal(terminal) {
+        terminalStore.set(terminal);
+        refreshWatchValues();
+        syncBreakpoints();
+    }
+    function setAdapter(adapter) {
+        adapterStore.set(adapter);
+        refreshWatchValues();
+    }
+    function setBreakpoints(lines) {
+        breakpointsStore.set([...lines]);
+        syncBreakpoints();
+    }
+    function setCursorLine(line) {
+        cursorLineStore.set(line);
+    }
+    function addWatchExpression(expression) {
+        const watchInput = get(watchInputStore);
+        const watchExpressions = get(watchExpressionsStore);
+        const nextExpression = (expression || watchInput).trim();
+        if (!nextExpression || watchExpressions.includes(nextExpression))
+            return false;
+        watchExpressionsStore.set([...watchExpressions, nextExpression]);
+        watchInputStore.set('');
+        refreshWatchValues();
+        return true;
+    }
+    function removeWatchExpression(expression) {
+        watchExpressionsStore.set(get(watchExpressionsStore).filter((entry) => entry !== expression));
+        refreshWatchValues();
+    }
+    function clearWatches() {
+        watchInputStore.set('');
+        watchExpressionsStore.set([]);
+        refreshWatchValues();
+    }
+    async function sendCommand(command) {
+        const terminal = get(terminalStore);
+        if (!terminal || !get(pausedStore))
+            return false;
+        await terminal.debugCommand(command);
+        return true;
+    }
+    async function runToCursor(targetLine = get(cursorLineStore)) {
+        const terminal = get(terminalStore);
+        const breakpoints = get(breakpointsStore);
+        if (!terminal ||
+            !get(pausedStore) ||
+            !targetLine ||
+            targetLine === get(pausedLineStore) ||
+            !terminal.setBreakpoints) {
+            return false;
+        }
+        const nextBreakpoints = breakpoints.includes(targetLine)
+            ? [...breakpoints]
+            : [...breakpoints, targetLine].sort((left, right) => left - right);
+        runToCursorLineStore.set(breakpoints.includes(targetLine) ? null : targetLine);
+        await terminal.setBreakpoints(nextBreakpoints);
+        await terminal.debugCommand('continue');
+        return true;
+    }
+    async function stop() {
+        const terminal = get(terminalStore);
+        if (!terminal)
+            return false;
+        reset();
+        await terminal.stop?.();
+        return true;
+    }
+    return {
+        get active() {
+            return activeState.current;
+        },
+        get paused() {
+            return pausedState.current;
+        },
+        get pausedLine() {
+            return pausedLineState.current;
+        },
+        get locals() {
+            return localsState.current;
+        },
+        get callStack() {
+            return callStackState.current;
+        },
+        get runToCursorLine() {
+            return runToCursorLineState.current;
+        },
+        get breakpoints() {
+            return breakpointsState.current;
+        },
+        get effectiveBreakpoints() {
+            return getEffectiveBreakpoints();
+        },
+        get cursorLine() {
+            return cursorLineState.current;
+        },
+        get canRunToCursor() {
+            const cursorLine = cursorLineState.current;
+            const terminal = terminalState.current;
+            return (pausedState.current &&
+                cursorLine !== null &&
+                cursorLine > 0 &&
+                cursorLine !== pausedLineState.current &&
+                !!terminal?.setBreakpoints);
+        },
+        get watchInput() {
+            return watchInputState.current;
+        },
+        set watchInput(value) {
+            watchInputStore.set(value);
+        },
+        get watchExpressions() {
+            return watchExpressionsState.current;
+        },
+        get watchValues() {
+            return watchValuesState.current;
+        },
+        begin,
+        reset,
+        handleEvent,
+        setTerminal,
+        setAdapter,
+        setBreakpoints,
+        setCursorLine,
+        sendCommand,
+        runToCursor,
+        stop,
+        addWatchExpression,
+        removeWatchExpression,
+        clearWatches
+    };
+}

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

@@ -1 +1,2 @@
-export { MonacoDebugView } from './monaco';
+export { MonacoDebugView, attachMonacoDebugActions } from './monaco';
+export type { MonacoDebugActionsOptions } from './monaco';

package/dist/debug/editor/index.js

@@ -1 +1 @@
-export { MonacoDebugView } from './monaco';
+export { MonacoDebugView, attachMonacoDebugActions } from './monaco';

package/dist/debug/editor/monaco.d.ts

@@ -1,6 +1,11 @@
 import type { DebugVariable } from '../../playground/options';
 import type { DebugLanguageAdapter } from '../language';
 import type monaco from 'monaco-editor';
+export type MonacoDebugActionsOptions = {
+    runToCursorLabel?: string;
+    onCursorLineChange?: (line: number | null) => void;
+    onRunToCursor?: (line: number | null) => void;
+};
 export declare class MonacoDebugView {
     Monaco: typeof monaco;
     editor: monaco.editor.IStandaloneCodeEditor;
@@ -16,3 +21,6 @@ export declare class MonacoDebugView {
     setPauseState(pausedLine: number | null, locals: DebugVariable[], adapter: DebugLanguageAdapter | null): void;
     dispose(): void;
 }
+export declare function attachMonacoDebugActions(editor: monaco.editor.IStandaloneCodeEditor, options?: MonacoDebugActionsOptions): {
+    dispose(): void;
+};

package/dist/debug/editor/monaco.js

@@ -103,3 +103,26 @@ export class MonacoDebugView {
         this.mouseHandler = null;
     }
 }
+export function attachMonacoDebugActions(editor, options = {}) {
+    const disposables = [];
+    disposables.push(editor.onDidChangeCursorPosition((event) => {
+        options.onCursorLineChange?.(event.position?.lineNumber || null);
+    }));
+    options.onCursorLineChange?.(editor.getPosition()?.lineNumber || 1);
+    if (options.onRunToCursor) {
+        disposables.push(editor.addAction({
+            id: 'wasm-idle-run-to-cursor',
+            label: options.runToCursorLabel || 'Run to Cursor',
+            contextMenuGroupId: 'navigation',
+            contextMenuOrder: 0.5,
+            run: () => options.onRunToCursor?.(editor.getPosition()?.lineNumber || null)
+        }));
+    }
+    return {
+        dispose() {
+            while (disposables.length)
+                disposables.pop()?.dispose();
+            options.onCursorLineChange?.(null);
+        }
+    };
+}

package/dist/debug/expression.d.ts

@@ -1,2 +1,26 @@
 import type { DebugVariable } from '../playground/options';
+export type DebugExpressionScalar = number | boolean | string | null;
+export type DebugExpressionArray = DebugExpressionValue[] & {
+    truncated?: boolean;
+};
+export interface DebugExpressionIndexedValue {
+    __debugExpressionKind: 'array';
+    length?: number;
+    truncated?: boolean;
+    get: (index: number) => DebugExpressionValue;
+    keys?: () => number[];
+}
+export interface DebugExpressionObjectValue {
+    __debugExpressionKind: 'object';
+    has: (name: string) => boolean;
+    get: (name: string) => DebugExpressionValue;
+    keys?: () => string[];
+}
+export interface DebugExpressionRecord {
+    [key: string]: DebugExpressionValue;
+}
+export type DebugExpressionValue = DebugExpressionScalar | DebugExpressionArray | DebugExpressionIndexedValue | DebugExpressionObjectValue | DebugExpressionRecord;
+export declare const parseStoredDebugValue: (value: string) => DebugExpressionValue;
+export declare const formatDebugExpressionValue: (value: DebugExpressionValue) => string;
+export declare const evaluateDebugExpressionWithResolver: (expression: string, resolveIdentifier: (name: string) => DebugExpressionValue) => string;
 export declare function evaluateDebugExpression(expression: string, variables: DebugVariable[]): string;