wasm-idle 0.7.2 → 1.0.0

package/dist/lsp/python/server.js

@@ -1,54 +0,0 @@
-import { resolvePythonLanguageServerBaseUrl } from '../runtime';
-import PythonLspWorker from './main.worker?worker';
-import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
-const currentUrl = () => globalThis.location?.href || '';
-async function createServer(pyodideBaseUrl) {
-    let resolveReady = () => { };
-    let rejectReady = (_error) => { };
-    const ready = new Promise((resolve, reject) => {
-        resolveReady = resolve;
-        rejectReady = reject;
-    });
-    const worker = new PythonLspWorker();
-    const cleanup = () => {
-        worker.removeEventListener('message', readyListener);
-        worker.removeEventListener('error', errorListener);
-    };
-    const readyListener = (event) => {
-        switch (event.data?.type) {
-            case 'ready': {
-                cleanup();
-                resolveReady();
-                break;
-            }
-            case 'error': {
-                cleanup();
-                rejectReady(new Error(event.data?.error || 'Python LSP worker failed to initialize'));
-                break;
-            }
-        }
-    };
-    const errorListener = (event) => {
-        cleanup();
-        rejectReady(event.error || new Error(event.message || 'Python LSP worker failed'));
-    };
-    worker.addEventListener('message', readyListener);
-    worker.addEventListener('error', errorListener);
-    worker.postMessage({ type: 'init', pyodideBaseUrl });
-    await ready;
-    return worker;
-}
-export async function getPythonLanguageServer(options) {
-    const pyodideBaseUrl = resolvePythonLanguageServerBaseUrl(options, currentUrl());
-    const worker = await createServer(pyodideBaseUrl);
-    const reader = new BrowserMessageReader(worker);
-    const writer = new BrowserMessageWriter(worker);
-    return {
-        transport: { reader, writer },
-        dispose: () => {
-            worker.terminate();
-            reader.dispose();
-            writer.dispose();
-        }
-    };
-}

package/dist/lsp/registry.d.ts

@@ -1,2 +0,0 @@
-import type { EditorLanguageServerRuntimeOptions, EditorLanguageServerHandle } from './types';
-export declare function getEditorLanguageServer(language: string, options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle | null>;

package/dist/lsp/registry.js

@@ -1,12 +0,0 @@
-import { getCppLanguageServer } from './cpp/server';
-import { getPythonLanguageServer } from './python/server';
-export async function getEditorLanguageServer(language, options) {
-    const normalized = language.toLowerCase();
-    if (normalized === 'c' || normalized === 'cpp') {
-        return getCppLanguageServer(options);
-    }
-    if (normalized === 'python') {
-        return getPythonLanguageServer(options);
-    }
-    return null;
-}

package/dist/lsp/runtime.d.ts

@@ -1,5 +0,0 @@
-import type { EditorLanguageServerRuntimeOptions } from './types';
-import { type ResolvedRuntimeAssetConfig } from '../playground/assets';
-export declare function resolveCppLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;
-export declare function resolveCppLanguageServerRuntimeAssetConfig(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
-export declare function resolvePythonLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;

package/dist/lsp/runtime.js

@@ -1,31 +0,0 @@
-import { resolveRuntimeAssetConfig } from '../playground/assets';
-const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
-    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-    return currentUrl ? new URL(normalized, currentUrl).href : normalized;
-};
-const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
-const resolveRuntimeRootBaseUrl = (rootUrl, suffix, currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}${suffix}`, currentUrl);
-export function resolveCppLanguageServerBaseUrl(options, currentUrl = '') {
-    return resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl).baseUrl;
-}
-export function resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl = '') {
-    if (typeof options === 'string') {
-        return resolveRuntimeAssetConfig('clangd', options, currentUrl);
-    }
-    return resolveRuntimeAssetConfig('clangd', {
-        rootUrl: options?.rootUrl,
-        clangd: options?.cpp
-    }, currentUrl);
-}
-export function resolvePythonLanguageServerBaseUrl(options, currentUrl = '') {
-    if (typeof options === 'string') {
-        return resolveRuntimeRootBaseUrl(options, '/pyodide/', currentUrl);
-    }
-    if (options?.python?.baseUrl) {
-        return normalizeBaseUrl(options.python.baseUrl, currentUrl);
-    }
-    if (options?.rootUrl) {
-        return resolveRuntimeRootBaseUrl(options.rootUrl, '/pyodide/', currentUrl);
-    }
-    return normalizeBaseUrl('/pyodide/', currentUrl);
-}

package/dist/lsp/types.d.ts

@@ -1,17 +0,0 @@
-import type { MessageTransports } from '@hancomac/monaco-languageclient';
-import type { RuntimeAssetLoader } from '../playground/assets';
-export interface EditorLanguageServerHandle {
-    transport: string | MessageTransports;
-    syncFile?: (path: string) => void;
-    dispose: () => void;
-}
-export interface EditorLanguageServerRuntimeOptions {
-    rootUrl?: string;
-    cpp?: {
-        baseUrl?: string;
-        loader?: RuntimeAssetLoader;
-    };
-    python?: {
-        baseUrl?: string;
-    };
-}

package/dist/terminal/Terminal.svelte

@@ -1,422 +0,0 @@
-<script lang="ts">
-	import type {
-		CompilerDiagnostic,
-		DebugCommand,
-		DebugSessionEvent,
-		SandboxExecutionOptions
-	} from '../playground/options';
-	import type { PlaygroundRuntimeAssets } from '../playground/assets';
-	import type {
-		BoundSandbox,
-		PlaygroundBinding,
-		SandboxRuntimeAssets
-	} from '../playground/sandbox';
-	import type { TerminalControl } from './types';
-	import { Theme, registerAllPlugins } from './';
-	import load from '../playground';
-	import { onMount } from 'svelte';
-	import '@xterm/xterm/css/xterm.css';
-	import type { Terminal as TerminalType } from '@xterm/xterm';
-
-	interface Props {
-		dark?: boolean;
-		path?: string;
-		runtimeAssets?: string | PlaygroundRuntimeAssets;
-		playground?: PlaygroundBinding;
-		font?: string;
-
-		onload?: () => void;
-		onfinish?: () => void;
-		onkey?: (e: KeyboardEvent) => void;
-		ondebug?: (event: DebugSessionEvent) => void;
-		oncompilediagnostic?: (diagnostic: CompilerDiagnostic) => void;
-		onimage?: (payload: { mime: string; b64: string; ts?: number }) => void;
-		terminal?: TerminalControl;
-	}
-
-	let {
-		dark = false,
-		path = '',
-		runtimeAssets = undefined,
-		playground = undefined,
-		font = "'D2 coding', monospace",
-		onload,
-		onfinish,
-		onkey,
-		ondebug,
-		oncompilediagnostic,
-		onimage,
-		terminal = $bindable()
-	}: Props = $props();
-
-	let ref = $state<HTMLElement>(),
-		clientWidth = $state(0),
-		clientHeight = $state(0),
-		term = $state<TerminalType>(),
-		debugOutput = $state(''),
-		finish = true,
-		input = '',
-		sandbox: BoundSandbox,
-		first = true,
-		tc = 0,
-		plugin = $state(),
-		ll: string | null = null,
-		loadedRuntimeAssetsKey: string | undefined = undefined,
-		stopRequested = false;
-
-	function writeTerminalOutput(text: string) {
-		if (!text) return;
-		debugOutput += text;
-		term?.write(text);
-	}
-
-	function phaseProgress(
-		progress: { set?: (value: number) => void } | undefined,
-		start: number,
-		end: number
-	) {
-		if (!progress) return undefined;
-		return {
-			set(value: number) {
-				const clamped = Number.isFinite(value) ? Math.min(Math.max(value, 0), 1) : 0;
-				progress.set?.(start + (end - start) * clamped);
-			}
-		};
-	}
-
-	function wait() {
-		return new Promise<void>((r) => {
-			const i = setInterval(() => {
-				if (term) {
-					clearInterval(i);
-					r();
-				}
-			}, 100);
-		});
-	}
-
-	async function initSandbox(language: string) {
-		const currentPlayground = playground;
-		const currentRuntimeAssets = currentPlayground?.runtimeAssets || runtimeAssets || path;
-		const currentRuntimeAssetsKey =
-			typeof currentRuntimeAssets === 'string'
-				? currentRuntimeAssets
-				: JSON.stringify({
-						rootUrl: currentRuntimeAssets?.rootUrl || '',
-						pythonBaseUrl: currentRuntimeAssets?.python?.baseUrl || '',
-						hasPythonLoader: !!currentRuntimeAssets?.python?.loader,
-						javaBaseUrl: currentRuntimeAssets?.java?.baseUrl || '',
-						hasJavaLoader: !!currentRuntimeAssets?.java?.loader,
-						clangBaseUrl: currentRuntimeAssets?.clang?.baseUrl || '',
-						hasClangLoader: !!currentRuntimeAssets?.clang?.loader,
-						clangdBaseUrl: currentRuntimeAssets?.clangd?.baseUrl || '',
-						hasClangdLoader: !!currentRuntimeAssets?.clangd?.loader,
-						rustCompilerUrl: currentRuntimeAssets?.rust?.compilerUrl || '',
-						goCompilerUrl: currentRuntimeAssets?.go?.compilerUrl || '',
-						elixirBundleUrl: currentRuntimeAssets?.elixir?.bundleUrl || '',
-						ocamlModuleUrl: currentRuntimeAssets?.ocaml?.moduleUrl || '',
-						ocamlManifestUrl: currentRuntimeAssets?.ocaml?.manifestUrl || '',
-						tinygoAppUrl: currentRuntimeAssets?.tinygo?.appUrl || '',
-						tinygoHostCompileUrl: currentRuntimeAssets?.tinygo?.hostCompileUrl || '',
-						tinygoModuleUrl: currentRuntimeAssets?.tinygo?.moduleUrl || '',
-						tinygoDisableHostCompile: !!currentRuntimeAssets?.tinygo?.disableHostCompile
-					});
-		const requiresSandboxReset =
-			ll !== language || loadedRuntimeAssetsKey !== currentRuntimeAssetsKey;
-		let _tc = ++tc;
-		await wait();
-		if (sandbox && requiresSandboxReset) await sandbox.clear();
-		input = '';
-		finish = false;
-		if (!sandbox || requiresSandboxReset) {
-			sandbox = currentPlayground
-				? await currentPlayground.load(language)
-				: await load(language, currentRuntimeAssets);
-			await sandbox.clear();
-			ll = language;
-			loadedRuntimeAssetsKey = currentRuntimeAssetsKey;
-		}
-		sandbox.image = onimage;
-		sandbox.ondebug = ondebug;
-		sandbox.oncompilerdiagnostic = oncompilediagnostic;
-		sandbox.output = (output: string) =>
-			_tc === tc && writeTerminalOutput(output.replaceAll('\n', '\r\n'));
-	}
-
-	function runSandbox<T>(pr: Promise<T>) {
-		return pr
-			.then((x) => {
-				writeTerminalOutput(`\r\nProcess finished after ${sandbox.elapse}ms\u001B[?25l`);
-				return x;
-			})
-			.catch((msg) => {
-				if (stopRequested) return false;
-				writeTerminalOutput(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
-				return false;
-			})
-			.finally(() => {
-				stopRequested = false;
-				onfinish?.();
-				finish = true;
-				if (term) term.options.cursorBlink = false;
-			});
-	}
-
-	async function initTerm(blink = true) {
-		await wait();
-		if (!term) return;
-		term.options.cursorBlink = blink;
-		term.write('\u001B[?25h');
-		term.focus();
-
-		if (!first) term?.write(`\r\n\x1b[0m`);
-		first = false;
-	}
-
-	function appendInputText(text: string) {
-		if (!text) return;
-		input += text;
-		term?.write(text);
-	}
-
-	function submitCurrentInput() {
-		term?.write('\r\n');
-		sandbox?.write?.(input + '\n');
-		input = '';
-	}
-
-	function applyPastedText(text: string) {
-		const lines = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n');
-		for (let i = 0; i < lines.length; i++) {
-			appendInputText(lines[i]);
-			if (i < lines.length - 1) submitCurrentInput();
-		}
-	}
-
-	async function waitForInput() {
-		await wait();
-		const startedAt = Date.now();
-		while (!sandbox && Date.now() - startedAt < 30_000) {
-			await new Promise((resolve) => setTimeout(resolve, 10));
-		}
-	}
-
-	const terminalControl: TerminalControl = {
-		async clear() {
-			await wait();
-			term?.reset();
-			term?.write(`\u001B[?25l\x1b[0m\x1b[?25h`);
-			if (term) term.options.cursorBlink = false;
-			debugOutput = '';
-			input = '';
-			first = true;
-			await new Promise((r) => setTimeout(r, 100));
-		},
-		async prepare(
-			language: string,
-			code: string,
-			log = true,
-			prog?: { set?: (value: number) => void },
-			args: string[] = [],
-			options: SandboxExecutionOptions = {}
-		) {
-			prog?.set?.(0);
-			const loadProgress =
-				language === 'RUST' ||
-				language === 'GO' ||
-				language === 'TINYGO' ||
-				language === 'OCAML'
-					? phaseProgress(prog, 0, 0.05)
-					: phaseProgress(prog, 0, 0.85);
-			const prepareProgress =
-				language === 'RUST' ||
-				language === 'GO' ||
-				language === 'TINYGO' ||
-				language === 'OCAML'
-					? phaseProgress(prog, 0.05, 0.99)
-					: phaseProgress(prog, 0.85, 0.99);
-			await Promise.all([
-				initSandbox(language).then(() =>
-					sandbox.load(code, log, args, options, loadProgress)
-				),
-				initTerm(false)
-			]);
-			prepareProgress?.set?.(0);
-			return !!(await runSandbox(
-				sandbox.run(code, true, log, prepareProgress, args, options)
-			));
-		},
-		async run(
-			language: string,
-			code: string,
-			log = true,
-			prog?: { set?: (value: number) => void },
-			args: string[] = [],
-			options: SandboxExecutionOptions = {}
-		) {
-			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(code, log, args, options, prog)),
-				initTerm()
-			]);
-			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
-		},
-		async destroy() {
-			await wait();
-			term?.dispose();
-			if (sandbox) await sandbox.clear();
-		},
-		async stop() {
-			await wait();
-			stopRequested = true;
-			finish = true;
-			if (sandbox?.kill) sandbox.kill();
-			else sandbox?.terminate?.();
-		},
-		async debugCommand(command: DebugCommand) {
-			await wait();
-			sandbox.debugCommand?.(command);
-		},
-		async setBreakpoints(lines: number[]) {
-			await wait();
-			sandbox.setBreakpoints?.(lines);
-		},
-		async debugEvaluate(expression: string) {
-			await wait();
-			return (await sandbox.debugEvaluate?.(expression)) || '?';
-		},
-		async waitForInput() {
-			await waitForInput();
-		},
-		async write(input: string) {
-			await waitForInput();
-			applyPastedText(input);
-			if (!input.endsWith('\n') && !input.endsWith('\r')) submitCurrentInput();
-		},
-		async eof() {
-			await waitForInput();
-			sandbox?.eof?.();
-		}
-	};
-
-	$effect(() => {
-		if (term) {
-			if (dark) term.options.theme = Theme.Tango_Dark;
-			else term.options.theme = Theme.Tango_Light;
-		}
-	});
-
-	$effect(() => {
-		let _ = clientWidth + clientHeight;
-		(plugin as any)?.fit?.fit?.();
-	});
-
-	$effect(() => {
-		terminal = terminalControl;
-	});
-
-	onMount(() => {
-		import('@xterm/xterm').then(async ({ Terminal }) => {
-			if (!ref) return;
-			term = new Terminal({
-				theme: dark ? Theme.Tango_Dark : Theme.Tango_Light,
-				cursorBlink: false,
-				allowTransparency: true,
-				fontFamily: font,
-				allowProposedApi: true
-			});
-			term.open(ref);
-			term.onData((data: string) => {
-				if (!term || finish) return;
-				let pendingText = '';
-				for (const chunk of data) {
-					if (chunk === '\r' || chunk === '\n') {
-						if (pendingText) {
-							appendInputText(pendingText);
-							pendingText = '';
-						}
-						submitCurrentInput();
-						continue;
-					}
-					if (chunk === '\u007f') {
-						if (pendingText) {
-							appendInputText(pendingText);
-							pendingText = '';
-						}
-						if (term.buffer.active.cursorX > 0 && input.length > 0) {
-							term.write('\b \b');
-							input = Array.from(input).slice(0, -1).join('');
-						}
-						continue;
-					}
-					if ((chunk.codePointAt(0) || 0) >= 0x20) {
-						pendingText += chunk;
-					}
-				}
-				if (pendingText) {
-					appendInputText(pendingText);
-				}
-			});
-			term.onKey((e: { key: string; domEvent: KeyboardEvent }) => {
-				if (!term) return;
-				const ev = e.domEvent;
-				const isCopyShortcut = (ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'c';
-				if (isCopyShortcut && term.hasSelection()) {
-					const selectedText = term.getSelection();
-					if (selectedText) {
-						ev.preventDefault();
-						navigator.clipboard.writeText(selectedText).catch(() => {});
-						return;
-					}
-				}
-				if (finish) return;
-				onkey?.(ev);
-				if (isCopyShortcut) {
-					ev.preventDefault();
-					sandbox.kill?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'd') {
-					ev.preventDefault();
-					if (input.length > 0) submitCurrentInput();
-					sandbox?.eof?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'v') {
-					ev.preventDefault();
-					navigator.clipboard.readText().then((text) => {
-						applyPastedText(text);
-					});
-				}
-			});
-			plugin = await registerAllPlugins(term);
-
-			onload?.();
-		});
-
-		return async () => {
-			term?.dispose();
-			if (sandbox) await sandbox.clear();
-		};
-	});
-</script>
-
-<main>
-	<div bind:this={ref} bind:clientWidth bind:clientHeight></div>
-	<pre data-testid="terminal-debug-output" style="display: none;">{debugOutput}</pre>
-</main>
-
-<style>
-	main {
-		padding: 10px;
-		width: calc(100% - 20px);
-		height: calc(100% - 20px);
-		overflow: hidden;
-	}
-
-	div {
-		width: 100%;
-		height: 100%;
-	}
-
-	:global(.xterm),
-	:global(.xterm .xterm-viewport),
-	:global(.xterm .composition-view) {
-		background-color: transparent;
-	}
-</style>

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

@@ -1,26 +0,0 @@
-import type { CompilerDiagnostic, DebugSessionEvent } from '../playground/options';
-import type { PlaygroundRuntimeAssets } from '../playground/assets';
-import type { PlaygroundBinding } from '../playground/sandbox';
-import type { TerminalControl } from './types';
-import '@xterm/xterm/css/xterm.css';
-interface Props {
-    dark?: boolean;
-    path?: string;
-    runtimeAssets?: string | PlaygroundRuntimeAssets;
-    playground?: PlaygroundBinding;
-    font?: string;
-    onload?: () => void;
-    onfinish?: () => void;
-    onkey?: (e: KeyboardEvent) => void;
-    ondebug?: (event: DebugSessionEvent) => void;
-    oncompilediagnostic?: (diagnostic: CompilerDiagnostic) => void;
-    onimage?: (payload: {
-        mime: string;
-        b64: string;
-        ts?: number;
-    }) => void;
-    terminal?: TerminalControl;
-}
-declare const Terminal: import("svelte").Component<Props, {}, "terminal">;
-type Terminal = ReturnType<typeof Terminal>;
-export default Terminal;

package/dist/terminal/index.d.ts

@@ -1,7 +0,0 @@
-import Theme from './theme';
-import registerAllPlugins from './plugin';
-import Terminal from './Terminal.svelte';
-import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './types';
-export { Theme, registerAllPlugins };
-export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl };
-export default Terminal;

package/dist/terminal/index.js

@@ -1,5 +0,0 @@
-import Theme from './theme';
-import registerAllPlugins from './plugin';
-import Terminal from './Terminal.svelte';
-export { Theme, registerAllPlugins };
-export default Terminal;

package/dist/terminal/plugin/index.d.ts

@@ -1,9 +0,0 @@
-import type { Terminal } from '@xterm/xterm';
-export default function registerAllPlugins(term: Terminal): Promise<{
-    fit: import("@xterm/addon-fit").FitAddon;
-    search: import("@xterm/addon-search").SearchAddon;
-    serialize: import("@xterm/addon-serialize").SerializeAddon;
-    weblink: import("@xterm/addon-web-links").WebLinksAddon;
-    webgl: import("@xterm/addon-webgl").WebglAddon;
-    unicode: import("@xterm/addon-unicode11").Unicode11Addon;
-}>;

package/dist/terminal/plugin/index.js

@@ -1,19 +0,0 @@
-export default async function registerAllPlugins(term) {
-    const { FitAddon } = await import('@xterm/addon-fit');
-    const { SearchAddon } = await import('@xterm/addon-search');
-    const { SerializeAddon } = await import('@xterm/addon-serialize');
-    const { WebLinksAddon } = await import('@xterm/addon-web-links');
-    const { WebglAddon } = await import('@xterm/addon-webgl');
-    const { Unicode11Addon } = await import('@xterm/addon-unicode11');
-    const plugins = {
-        fit: new FitAddon(),
-        search: new SearchAddon(),
-        serialize: new SerializeAddon(),
-        weblink: new WebLinksAddon(),
-        webgl: new WebglAddon(),
-        unicode: new Unicode11Addon()
-    };
-    for (const plugin in plugins)
-        term.loadAddon(plugins[plugin]);
-    return plugins;
-}

package/dist/terminal/theme.d.ts

@@ -1,49 +0,0 @@
-declare const theme: {
-    Tango_Dark: {
-        foreground: string;
-        background: string;
-        cursor: string;
-        cursorAccent: string;
-        selection: string;
-        black: string;
-        red: string;
-        green: string;
-        yellow: string;
-        blue: string;
-        magenta: string;
-        cyan: string;
-        white: string;
-        brightBlack: string;
-        brightRed: string;
-        brightGreen: string;
-        brightYellow: string;
-        brightBlue: string;
-        brightMagenta: string;
-        brightCyan: string;
-        brightWhite: string;
-    };
-    Tango_Light: {
-        foreground: string;
-        background: string;
-        cursor: string;
-        cursorAccent: string;
-        selection: string;
-        black: string;
-        red: string;
-        green: string;
-        yellow: string;
-        blue: string;
-        magenta: string;
-        cyan: string;
-        white: string;
-        brightBlack: string;
-        brightRed: string;
-        brightGreen: string;
-        brightYellow: string;
-        brightBlue: string;
-        brightMagenta: string;
-        brightCyan: string;
-        brightWhite: string;
-    };
-};
-export default theme;