@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-zentui/extensions/zentui/selector-border.ts

@@ -0,0 +1,93 @@
+import {
+	ModelSelectorComponent,
+	SettingsSelectorComponent,
+	type Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { ZentuiConfig } from "./config";
+import { installPrototypePatch, removePrototypePatch } from "./prototype-patch-registry";
+import { EDITOR_BORDER_STYLE, renderChromeBorder, renderEditorBorder } from "./style";
+
+type PatchableSelectorPrototype = {
+	render: (width: number) => string[];
+};
+
+type Cleanup = () => void;
+
+function stripAnsi(text: string): string {
+	return text.replaceAll(/\x1b\[[0-9;]*m/g, "");
+}
+
+function isHorizontalBorderLine(line: string): boolean {
+	return /^─+$/.test(stripAnsi(line));
+}
+
+function renderBorderLine(
+	width: number,
+	theme: Theme | undefined,
+	config: ZentuiConfig | undefined,
+): string {
+	const text = "─".repeat(Math.max(1, width));
+	if (theme && config) {
+		return renderChromeBorder(
+			theme,
+			config.components.selectorBorders.colorSource,
+			EDITOR_BORDER_STYLE,
+			text,
+		);
+	}
+	return renderEditorBorder(text);
+}
+
+export function patchSelectorBorderStyle(
+	prototype: PatchableSelectorPrototype,
+	getTheme?: () => Theme | undefined,
+	getConfig?: () => ZentuiConfig,
+): Cleanup {
+	return installPrototypePatch(
+		prototype,
+		"render",
+		"selector-border-render",
+		({ predecessor, receiver, args }) => {
+			const lines = Reflect.apply(predecessor, receiver, args) as string[];
+			const width = args[0];
+			if (lines.length === 0 || typeof width !== "number" || width <= 0) return lines;
+
+			return lines.map((line, index) => {
+				if (index !== 0 && index !== lines.length - 1) return line;
+				if (!isHorizontalBorderLine(line)) return line;
+				return renderBorderLine(width, getTheme?.(), getConfig?.());
+			});
+		},
+	);
+}
+
+export function removeSelectorBorderStyle(): void {
+	removePrototypePatch(ModelSelectorComponent.prototype, "render", "selector-border-render");
+	removePrototypePatch(SettingsSelectorComponent.prototype, "render", "selector-border-render");
+}
+
+export function installSelectorBorderStyle(
+	getTheme?: () => Theme | undefined,
+	getConfig?: () => ZentuiConfig,
+): Cleanup {
+	const cleanupModel = patchSelectorBorderStyle(
+		ModelSelectorComponent.prototype as unknown as PatchableSelectorPrototype,
+		getTheme,
+		getConfig,
+	);
+	let cleanupSettings: Cleanup;
+	try {
+		cleanupSettings = patchSelectorBorderStyle(
+			SettingsSelectorComponent.prototype as unknown as PatchableSelectorPrototype,
+			getTheme,
+			getConfig,
+		);
+	} catch (error) {
+		cleanupModel();
+		throw error;
+	}
+	return () => {
+		cleanupModel();
+		cleanupSettings();
+	};
+}

package/dist/extensions/pi-zentui/extensions/zentui/session-lifecycle.ts

@@ -0,0 +1,60 @@
+export class SessionLifecycle {
+	private generation = 0;
+	private active = false;
+	private readonly timeouts = new Set<ReturnType<typeof setTimeout>>();
+
+	start(): number {
+		this.cancelTimeouts();
+		this.generation += 1;
+		this.active = true;
+		return this.generation;
+	}
+
+	currentGeneration(): number {
+		return this.generation;
+	}
+
+	isCurrent(generation = this.generation): boolean {
+		return this.active && generation === this.generation;
+	}
+
+	defer(callback: () => void, delayMs = 0): () => void {
+		if (!this.active) return () => {};
+		const generation = this.generation;
+		let canceled = false;
+		const timeout = setTimeout(() => {
+			this.timeouts.delete(timeout);
+			if (!canceled && this.isCurrent(generation)) callback();
+		}, delayMs);
+		this.timeouts.add(timeout);
+		return () => {
+			if (canceled) return;
+			canceled = true;
+			clearTimeout(timeout);
+			this.timeouts.delete(timeout);
+		};
+	}
+
+	queueMicrotask(callback: () => void): () => void {
+		let canceled = !this.active;
+		const generation = this.generation;
+		queueMicrotask(() => {
+			if (!canceled && this.isCurrent(generation)) callback();
+		});
+		return () => {
+			canceled = true;
+		};
+	}
+
+	shutdown(): void {
+		if (!this.active && this.timeouts.size === 0) return;
+		this.active = false;
+		this.generation += 1;
+		this.cancelTimeouts();
+	}
+
+	private cancelTimeouts(): void {
+		for (const timeout of this.timeouts) clearTimeout(timeout);
+		this.timeouts.clear();
+	}
+}