@aitty/browser 0.1.0

package/dist/frontend/terminal-input-policies.d.ts

@@ -0,0 +1,24 @@
+//#region src/frontend/terminal-input-policies.d.ts
+type TerminalInputHost = {
+  bridge?: {
+    bracketedPaste?: () => boolean;
+    cursorKeysApp?: () => boolean;
+  } | null;
+  element?: HTMLElement | null;
+  input?: {
+    textarea?: HTMLTextAreaElement | null;
+  } | null;
+} | null | undefined;
+type TerminalKeyResolver = (event: KeyboardEvent) => string | null | undefined;
+type TerminalInputCallbacks = {
+  captureDocumentCtrlN?: boolean;
+  onData?: (data: string) => void;
+  resolveKey?: TerminalKeyResolver;
+  resolveDocumentKeyData?: (event: KeyboardEvent) => string | null;
+};
+declare function installTerminalInputPolicies(term: TerminalInputHost, callbacks?: TerminalInputCallbacks): () => void;
+declare function isBrowserSafeShortcut(event: KeyboardEvent): boolean;
+declare function isContainedTerminalNavigationKey(event: KeyboardEvent): boolean;
+declare function isCompositionKeyDown(event: KeyboardEvent): boolean;
+//#endregion
+export { TerminalInputCallbacks, TerminalKeyResolver, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey };

package/dist/frontend/terminal-input-policies.js

@@ -0,0 +1,462 @@
+//#region src/frontend/terminal-input-policies.ts
+const RESERVED_BROWSER_SHORTCUT_KEYS = new Set(["r", "w"]);
+const CONTAINED_TERMINAL_NAVIGATION_KEYS = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]);
+const NORMAL_NAVIGATION_SEQUENCES = Object.freeze({
+	ArrowDown: "\x1B[B",
+	ArrowLeft: "\x1B[D",
+	ArrowRight: "\x1B[C",
+	ArrowUp: "\x1B[A",
+	End: "\x1B[F",
+	Home: "\x1B[H"
+});
+const APPLICATION_NAVIGATION_SEQUENCES = Object.freeze({
+	ArrowDown: "\x1BOB",
+	ArrowLeft: "\x1BOD",
+	ArrowRight: "\x1BOC",
+	ArrowUp: "\x1BOA",
+	End: "\x1BOF",
+	Home: "\x1BOH"
+});
+const FIXED_KEY_SEQUENCES = Object.freeze({
+	Backspace: "",
+	Delete: "\x1B[3~",
+	Enter: "\r",
+	Escape: "\x1B",
+	F1: "\x1BOP",
+	F10: "\x1B[21~",
+	F11: "\x1B[23~",
+	F12: "\x1B[24~",
+	F2: "\x1BOQ",
+	F3: "\x1BOR",
+	F4: "\x1BOS",
+	F5: "\x1B[15~",
+	F6: "\x1B[17~",
+	F7: "\x1B[18~",
+	F8: "\x1B[19~",
+	F9: "\x1B[20~",
+	Insert: "\x1B[2~",
+	PageDown: "\x1B[6~",
+	PageUp: "\x1B[5~",
+	Tab: "	"
+});
+const ALT_PRINTABLE_CODE_MAP = Object.freeze({
+	Backquote: "`",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Backslash: "\\",
+	Comma: ",",
+	Digit0: "0",
+	Digit1: "1",
+	Digit2: "2",
+	Digit3: "3",
+	Digit4: "4",
+	Digit5: "5",
+	Digit6: "6",
+	Digit7: "7",
+	Digit8: "8",
+	Digit9: "9",
+	Equal: "=",
+	KeyA: "a",
+	KeyB: "b",
+	KeyC: "c",
+	KeyD: "d",
+	KeyE: "e",
+	KeyF: "f",
+	KeyG: "g",
+	KeyH: "h",
+	KeyI: "i",
+	KeyJ: "j",
+	KeyK: "k",
+	KeyL: "l",
+	KeyM: "m",
+	KeyN: "n",
+	KeyO: "o",
+	KeyP: "p",
+	KeyQ: "q",
+	KeyR: "r",
+	KeyS: "s",
+	KeyT: "t",
+	KeyU: "u",
+	KeyV: "v",
+	KeyW: "w",
+	KeyX: "x",
+	KeyY: "y",
+	KeyZ: "z",
+	Minus: "-",
+	Period: ".",
+	Quote: "'",
+	Semicolon: ";",
+	Slash: "/",
+	Space: " "
+});
+function installTerminalInputPolicies(term, callbacks = {}) {
+	const root = term?.element;
+	const textarea = term?.input?.textarea;
+	const ownerDocument = root?.ownerDocument;
+	const onData = callbacks.onData ?? (() => {});
+	const captureDocumentCtrlN = callbacks.captureDocumentCtrlN === true;
+	const resolveKey = callbacks.resolveKey ?? (() => null);
+	const resolveDocumentKeyData = callbacks.resolveDocumentKeyData ?? (() => null);
+	if (!(root instanceof HTMLElement) || !(textarea instanceof HTMLTextAreaElement) || !(ownerDocument instanceof Document)) return () => {};
+	let composing = false;
+	let pendingCompositionCommit = false;
+	let suppressedCompositionValue = "";
+	let latestCompositionValue = "";
+	let speculativePlainInputText = "";
+	let pendingSyntheticPrintableText = "";
+	let syntheticPrintableFlushQueued = false;
+	const clearSpeculativePlainInputText = () => {
+		speculativePlainInputText = "";
+	};
+	const clearPendingSyntheticPrintableText = () => {
+		pendingSyntheticPrintableText = "";
+	};
+	const flushPendingSyntheticPrintableText = () => {
+		if (!pendingSyntheticPrintableText) return;
+		const pendingText = pendingSyntheticPrintableText;
+		pendingSyntheticPrintableText = "";
+		onData(pendingText);
+	};
+	const clearPendingTextState = () => {
+		clearSpeculativePlainInputText();
+		clearPendingSyntheticPrintableText();
+	};
+	const flushPendingTextState = () => {
+		clearSpeculativePlainInputText();
+		flushPendingSyntheticPrintableText();
+	};
+	const deferSyntheticPrintableText = (text) => {
+		pendingSyntheticPrintableText += text;
+		if (syntheticPrintableFlushQueued) return;
+		syntheticPrintableFlushQueued = true;
+		queueMicrotask(() => {
+			syntheticPrintableFlushQueued = false;
+			if (composing || !pendingSyntheticPrintableText) return;
+			const pendingText = pendingSyntheticPrintableText;
+			pendingSyntheticPrintableText = "";
+			onData(pendingText);
+		});
+	};
+	const rollBackSpeculativePlainInputText = (preeditText) => {
+		const rollbackText = resolveSpeculativeRollbackText(speculativePlainInputText, preeditText);
+		if (!rollbackText) return;
+		const rollback = "".repeat([...rollbackText].length);
+		speculativePlainInputText = speculativePlainInputText.slice(0, -rollbackText.length);
+		onData(rollback);
+	};
+	const sendText = (text) => {
+		if (!text) return;
+		onData(text);
+	};
+	const handleDocumentKeyDownCapture = (event) => {
+		if (event.target === textarea) return;
+		const documentKeyData = captureDocumentCtrlN && !event.altKey && !event.metaKey && event.ctrlKey && event.key.toLowerCase() === "n" ? "" : resolveDocumentKeyData(event);
+		if (documentKeyData === null) return;
+		flushPendingTextState();
+		event.preventDefault();
+		stopInputPropagation(event);
+		onData(documentKeyData);
+	};
+	const handleKeyDownCapture = (event) => {
+		if (isBrowserSafeShortcut(event)) {
+			flushPendingTextState();
+			stopInputPropagation(event);
+			return;
+		}
+		if (isCopyShortcutWithTerminalSelection(root, event)) {
+			flushPendingTextState();
+			stopInputPropagation(event);
+			return;
+		}
+		const customKeyData = resolveKey(event);
+		if (customKeyData != null) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(customKeyData);
+			return;
+		}
+		const normalizedAltSequence = resolveAltPrintableSequence(event);
+		if (normalizedAltSequence) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(normalizedAltSequence);
+			return;
+		}
+		if (composing || isCompositionKeyDown(event)) {
+			stopInputPropagation(event);
+			return;
+		}
+		if (isPlainPrintableKey(event)) {
+			pendingCompositionCommit = false;
+			suppressedCompositionValue = "";
+			latestCompositionValue = "";
+			stopInputPropagation(event);
+			if (!event.isTrusted) {
+				event.preventDefault();
+				deferSyntheticPrintableText(event.key);
+			}
+			return;
+		}
+		const terminalSequence = resolveTerminalKeySequence(term, event);
+		if (terminalSequence !== null) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(terminalSequence);
+			return;
+		}
+		if (isContainedTerminalNavigationKey(event)) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+		}
+	};
+	const handleCompositionStartCapture = (event) => {
+		clearPendingSyntheticPrintableText();
+		composing = true;
+		pendingCompositionCommit = false;
+		suppressedCompositionValue = "";
+		latestCompositionValue = "";
+		stopInputPropagation(event);
+	};
+	const handleCompositionEndCapture = (event) => {
+		clearPendingTextState();
+		composing = false;
+		stopInputPropagation(event);
+		pendingCompositionCommit = false;
+		const value = normalizeCompositionCommit(event.data);
+		if (!value) {
+			const fallbackValue = textarea.value;
+			if (latestCompositionValue && fallbackValue && fallbackValue !== latestCompositionValue) {
+				latestCompositionValue = "";
+				suppressedCompositionValue = fallbackValue;
+				sendText(fallbackValue);
+				textarea.value = "";
+				return;
+			}
+			pendingCompositionCommit = true;
+			return;
+		}
+		latestCompositionValue = "";
+		suppressedCompositionValue = value;
+		sendText(value);
+		textarea.value = "";
+	};
+	const handleInputCapture = (event) => {
+		if (composing || isComposingInput(event)) {
+			if (isCompositionPreeditInput(event)) {
+				clearPendingSyntheticPrintableText();
+				rollBackSpeculativePlainInputText(textarea.value);
+			} else clearPendingTextState();
+			latestCompositionValue = textarea.value;
+			stopInputPropagation(event);
+			return;
+		}
+		const value = textarea.value;
+		const compositionInput = isCompositionInput(event);
+		const compositionPreeditInput = isCompositionPreeditInput(event);
+		if (pendingCompositionCommit) {
+			clearPendingTextState();
+			stopInputPropagation(event);
+			if (!value) {
+				textarea.value = "";
+				if (!compositionInput) {
+					pendingCompositionCommit = false;
+					latestCompositionValue = "";
+				}
+				return;
+			}
+			if (compositionPreeditInput && value === latestCompositionValue) {
+				textarea.value = "";
+				return;
+			}
+			pendingCompositionCommit = false;
+			latestCompositionValue = "";
+			suppressedCompositionValue = resolveCommittedInputText(event, value);
+			sendText(suppressedCompositionValue);
+			textarea.value = "";
+			return;
+		}
+		if (compositionPreeditInput) {
+			clearPendingSyntheticPrintableText();
+			latestCompositionValue = value;
+			stopInputPropagation(event);
+			return;
+		}
+		if (suppressedCompositionValue) {
+			if (!value || value === suppressedCompositionValue) {
+				suppressedCompositionValue = "";
+				stopInputPropagation(event);
+				textarea.value = "";
+				return;
+			}
+			suppressedCompositionValue = "";
+		}
+		if (!value) return;
+		latestCompositionValue = "";
+		stopInputPropagation(event);
+		textarea.value = "";
+		if (compositionInput) {
+			const committedText = resolveCommittedInputText(event, value);
+			suppressedCompositionValue = committedText;
+			sendText(committedText);
+			return;
+		}
+		const inputText = resolvePlainInputText(event, value);
+		if (isPotentialImeSeedText(inputText)) speculativePlainInputText += inputText;
+		else clearSpeculativePlainInputText();
+		sendText(inputText);
+	};
+	const handleCopy = (event) => {
+		const selectionText = getSelectionText(root);
+		if (!selectionText || !event.clipboardData?.setData) return;
+		event.clipboardData.setData("text/plain", selectionText);
+		event.preventDefault();
+	};
+	const handlePaste = (event) => {
+		flushPendingTextState();
+		const text = event.clipboardData?.getData("text") ?? event.clipboardData?.getData("text/plain") ?? "";
+		if (!text) return;
+		event.preventDefault();
+		stopInputPropagation(event);
+		if (term?.bridge?.bracketedPaste?.() === true) {
+			onData(`\u001b[200~${text.split("\x1B").join("")}\u001b[201~`);
+			return;
+		}
+		onData(text);
+	};
+	ownerDocument.addEventListener("keydown", handleDocumentKeyDownCapture, true);
+	textarea.addEventListener("keydown", handleKeyDownCapture, true);
+	textarea.addEventListener("compositionstart", handleCompositionStartCapture, true);
+	textarea.addEventListener("compositionend", handleCompositionEndCapture, true);
+	textarea.addEventListener("input", handleInputCapture, true);
+	textarea.addEventListener("paste", handlePaste, true);
+	ownerDocument.addEventListener("copy", handleCopy, true);
+	return () => {
+		ownerDocument.removeEventListener("keydown", handleDocumentKeyDownCapture, true);
+		textarea.removeEventListener("keydown", handleKeyDownCapture, true);
+		textarea.removeEventListener("compositionstart", handleCompositionStartCapture, true);
+		textarea.removeEventListener("compositionend", handleCompositionEndCapture, true);
+		textarea.removeEventListener("input", handleInputCapture, true);
+		textarea.removeEventListener("paste", handlePaste, true);
+		ownerDocument.removeEventListener("copy", handleCopy, true);
+	};
+}
+function isBrowserSafeShortcut(event) {
+	if (event.altKey) return false;
+	if (!(event.metaKey && !event.ctrlKey || event.ctrlKey && !event.metaKey)) return false;
+	return RESERVED_BROWSER_SHORTCUT_KEYS.has(event.key.toLowerCase());
+}
+function isContainedTerminalNavigationKey(event) {
+	if (!CONTAINED_TERMINAL_NAVIGATION_KEYS.has(event.key)) return false;
+	if (event.altKey || event.ctrlKey || event.metaKey) return false;
+	return !(event.shiftKey && (event.key === "PageUp" || event.key === "PageDown"));
+}
+function resolveAltPrintableSequence(event) {
+	if (!event.altKey || event.ctrlKey || event.metaKey) return null;
+	const baseKey = ALT_PRINTABLE_CODE_MAP[event.code];
+	if (!baseKey) return null;
+	return `\u001b${baseKey}`;
+}
+function isPlainPrintableKey(event) {
+	if (event.altKey || event.ctrlKey || event.metaKey) return false;
+	return event.key.length === 1;
+}
+function resolveTerminalKeySequence(term, event) {
+	if (event.metaKey && !event.ctrlKey) {
+		if (event.key === "Backspace") return "";
+		return null;
+	}
+	if (event.ctrlKey) {
+		const controlSequence = resolveControlKeySequence(event);
+		return event.altKey && controlSequence ? `\u001b${controlSequence}` : controlSequence;
+	}
+	if (event.key === "Enter" && event.shiftKey) return "\x1B[13;2u";
+	if (event.key === "Tab" && event.shiftKey) return "\x1B[Z";
+	const fixedSequence = FIXED_KEY_SEQUENCES[event.key];
+	if (fixedSequence) return event.altKey ? `\u001b${fixedSequence}` : fixedSequence;
+	const navigationSequence = (term?.bridge?.cursorKeysApp?.() === true ? APPLICATION_NAVIGATION_SEQUENCES : NORMAL_NAVIGATION_SEQUENCES)[event.key];
+	if (navigationSequence) return event.altKey ? `\u001b${navigationSequence}` : navigationSequence;
+	return null;
+}
+function resolveControlKeySequence(event) {
+	if (event.key.length !== 1) return null;
+	const key = event.key.toLowerCase();
+	if (key >= "a" && key <= "z") return String.fromCharCode(key.charCodeAt(0) - 96);
+	return {
+		" ": "\0",
+		"[": "\x1B",
+		"\\": "",
+		"]": "",
+		"^": "",
+		"_": ""
+	}[key] ?? null;
+}
+function isCompositionKeyDown(event) {
+	return event.isComposing || event.key === "Process" || event.key === "Dead" || event.keyCode === 229 || event.which === 229;
+}
+function isCompositionInput(event) {
+	return typeof event.inputType === "string" && event.inputType.toLowerCase().includes("composition");
+}
+function isCompositionPreeditInput(event) {
+	return event.inputType === "insertCompositionText";
+}
+function isComposingInput(event) {
+	return event.isComposing || isCompositionPreeditInput(event);
+}
+function resolvePlainInputText(event, textareaValue) {
+	if (typeof event.data === "string" && event.data.length > 0) return event.data;
+	if (event.inputType === "insertLineBreak") return "\r";
+	if (event.inputType === "deleteContentBackward") return "";
+	if (event.inputType === "deleteContentForward") return "\x1B[3~";
+	return textareaValue;
+}
+function resolveCommittedInputText(event, textareaValue) {
+	if (typeof event.data === "string" && event.data.length > 0) return event.data;
+	return textareaValue;
+}
+function isPotentialImeSeedText(text) {
+	return /^[0-9A-Za-z']$/.test(text);
+}
+function resolveSpeculativeRollbackText(sentText, preeditText) {
+	if (!sentText || !preeditText || !preeditText.startsWith(sentText)) return "";
+	return sentText;
+}
+function normalizeCompositionCommit(data) {
+	if (typeof data === "string" && data.length > 0) return data;
+	return "";
+}
+function getSelectionText(root) {
+	const selection = root.ownerDocument?.getSelection?.();
+	if (!selection || selection.isCollapsed) return "";
+	if (!nodeIsInsideRoot(root, selection.anchorNode) || !nodeIsInsideRoot(root, selection.focusNode)) return "";
+	return selection.toString();
+}
+function isCopyShortcutWithTerminalSelection(root, event) {
+	if (event.altKey || event.key.toLowerCase() !== "c") return false;
+	if (!(event.metaKey || event.ctrlKey)) return false;
+	return getSelectionText(root).length > 0;
+}
+function nodeIsInsideRoot(root, node) {
+	if (!node) return false;
+	if (node === root) return true;
+	if (node instanceof Element) return root.contains(node);
+	return node.parentElement ? root.contains(node.parentElement) : false;
+}
+function stopInputPropagation(event) {
+	event.stopPropagation();
+	if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
+}
+//#endregion
+export { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey };

package/dist/frontend/terminal-theme-protocol.d.ts

@@ -0,0 +1,22 @@
+//#region src/frontend/terminal-theme-protocol.d.ts
+type TerminalThemeName = "dark" | "light";
+type TerminalThemeProtocolUpdate = {
+  colors: Partial<Record<TerminalThemeColorSlot, string>>;
+  palette: TerminalThemePaletteUpdate[];
+  theme?: TerminalThemeName;
+};
+type TerminalThemeColorSlot = "background" | "cursor" | "foreground";
+type TerminalThemePaletteUpdate = {
+  color: string;
+  index: number;
+};
+declare function createTerminalThemeProtocolParser(): {
+  append(chunk: Uint8Array): TerminalThemeProtocolUpdate | null;
+  reset(): void;
+};
+declare function resolveTerminalThemeQueryResponse(chunk: string | Uint8Array, options: {
+  root: HTMLElement;
+  theme?: string;
+}): string | null;
+//#endregion
+export { TerminalThemeColorSlot, TerminalThemeName, TerminalThemePaletteUpdate, TerminalThemeProtocolUpdate, createTerminalThemeProtocolParser, resolveTerminalThemeQueryResponse };