@fyeeme/pi-thinking-ui 1.0.0 → 1.1.0

package/state.ts

@@ -1,47 +1,20 @@
-import type { ActiveThinkingState, ThinkingUIMode } from "./types.ts";
+import type { ThinkingUIMode } from "./types.ts";
 
 const STATE_KEY = Symbol.for("pi-extensions.thinking-ui.state");
 const DEFAULT_SCOPE_KEY = "__default__";
 const LABEL_REFRESH_SUFFIX = "\u2060";
 
-type PatchCleanup = () => void | Promise<void>;
-type PatchInstallPromise = Promise<PatchCleanup>;
-type PatchRelease = () => Promise<void>;
-
-interface ThinkingActiveEntry {
-	contentIndex?: number;
-}
-
 interface ThinkingUIGlobalState {
 	currentScopeKey: string;
 	modeByScopeKey: Record<string, ThinkingUIMode>;
-	activeByScopeKey: Record<string, Record<string, ThinkingActiveEntry>>;
-	lastActiveByScopeKey: Record<string, ActiveThinkingState>;
 	refreshToggleByScope: Record<string, boolean>;
-	messageScopeByObject: WeakMap<object, string>;
-	messageObjectsByScope: Record<string, Set<object>>;
-	messageScopeByTimestamp: Record<string, string>;
-	patchReleasesByScope: Record<string, PatchRelease[]>;
-	patchRefCount: number;
-	patchCleanup?: PatchCleanup | undefined;
-	patchInstallPromise?: PatchInstallPromise | undefined;
 }
 
 interface LegacyThinkingUIGlobalState {
 	mode?: unknown;
-	active?: unknown;
 	currentScopeKey?: unknown;
 	modeByScopeKey?: unknown;
-	activeByScopeKey?: unknown;
-	lastActiveByScopeKey?: unknown;
 	refreshToggleByScope?: unknown;
-	messageScopeByObject?: unknown;
-	messageObjectsByScope?: unknown;
-	messageScopeByTimestamp?: unknown;
-	patchReleasesByScope?: unknown;
-	patchRefCount?: unknown;
-	patchCleanup?: unknown;
-	patchInstallPromise?: unknown;
 }
 
 function isRecord(value: unknown): value is Record<PropertyKey, unknown> {
@@ -54,18 +27,7 @@ function normalizeThinkingScopeKey(scopeKey?: string): string {
 }
 
 function normalizeThinkingMode(mode: unknown): ThinkingUIMode {
-	return mode === "collapsed" || mode === "summary" || mode === "expanded" ? mode : "summary";
-}
-
-function normalizeActiveThinkingState(value: unknown): ActiveThinkingState {
-	if (!isRecord(value) || value.active !== true) {
-		return { active: false };
-	}
-	return {
-		active: true,
-		messageTimestamp: typeof value.messageTimestamp === "number" ? value.messageTimestamp : undefined,
-		contentIndex: typeof value.contentIndex === "number" ? value.contentIndex : undefined,
-	};
+	return mode === "collapsed" || mode === "summary" || mode === "expanded" ? mode : "collapsed";
 }
 
 function normalizeModeByScopeKey(value: unknown, currentScopeKey: string, legacyMode: unknown): Record<string, ThinkingUIMode> {
@@ -79,84 +41,20 @@ function normalizeModeByScopeKey(value: unknown, currentScopeKey: string, legacy
 	return modeByScopeKey;
 }
 
-function normalizeActiveByScopeKey(value: unknown): Record<string, Record<string, ThinkingActiveEntry>> {
-	const activeByScopeKey: Record<string, Record<string, ThinkingActiveEntry>> = {};
-	if (!isRecord(value)) return activeByScopeKey;
-	for (const [scopeKey, entries] of Object.entries(value)) {
-		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
-		activeByScopeKey[normalizedScopeKey] = {};
-		if (!isRecord(entries)) continue;
-		for (const [messageTimestamp, entry] of Object.entries(entries)) {
-			if (!isRecord(entry)) continue;
-			activeByScopeKey[normalizedScopeKey]![messageTimestamp] = {
-				contentIndex: typeof entry.contentIndex === "number" ? entry.contentIndex : undefined,
-			};
-		}
-	}
-	return activeByScopeKey;
-}
-
-function normalizeLastActiveByScopeKey(value: unknown): Record<string, ActiveThinkingState> {
-	const lastActiveByScopeKey: Record<string, ActiveThinkingState> = {};
-	if (!isRecord(value)) return lastActiveByScopeKey;
-	for (const [scopeKey, entry] of Object.entries(value)) {
-		lastActiveByScopeKey[normalizeThinkingScopeKey(scopeKey)] = normalizeActiveThinkingState(entry);
-	}
-	return lastActiveByScopeKey;
-}
-
 function ensureGlobalStateShape(state: ThinkingUIGlobalState & LegacyThinkingUIGlobalState): ThinkingUIGlobalState {
 	const currentScopeKey = normalizeThinkingScopeKey(typeof state.currentScopeKey === "string" ? state.currentScopeKey : undefined);
 	const modeByScopeKey = normalizeModeByScopeKey(state.modeByScopeKey, currentScopeKey, state.mode);
-	const activeByScopeKey = normalizeActiveByScopeKey(state.activeByScopeKey);
-	const lastActiveByScopeKey = normalizeLastActiveByScopeKey(state.lastActiveByScopeKey);
-	const legacyActive = normalizeActiveThinkingState(state.active);
 	const refreshToggleByScope: Record<string, boolean> = isRecord(state.refreshToggleByScope)
 		? Object.fromEntries(Object.entries(state.refreshToggleByScope).map(([scopeKey, enabled]) => [normalizeThinkingScopeKey(scopeKey), enabled === true]))
 		: {};
-	const messageScopeByObject = state.messageScopeByObject instanceof WeakMap ? state.messageScopeByObject as WeakMap<object, string> : new WeakMap<object, string>();
-	const messageObjectsByScope: Record<string, Set<object>> = isRecord(state.messageObjectsByScope)
-		? Object.fromEntries(Object.entries(state.messageObjectsByScope).map(([scopeKey, messages]) => [normalizeThinkingScopeKey(scopeKey), messages instanceof Set ? messages as Set<object> : new Set<object>()]))
-		: {};
-	const messageScopeByTimestamp: Record<string, string> = isRecord(state.messageScopeByTimestamp)
-		? Object.fromEntries(Object.entries(state.messageScopeByTimestamp).filter((entry): entry is [string, string] => typeof entry[1] === "string").map(([messageTimestamp, scopeKey]) => [messageTimestamp, normalizeThinkingScopeKey(scopeKey)]))
-		: {};
-	const legacyPatchReleasesByScope: Record<string, PatchRelease[]> = isRecord(state.patchReleasesByScope)
-		? Object.fromEntries(Object.entries(state.patchReleasesByScope).map(([scopeKey, releases]) => [normalizeThinkingScopeKey(scopeKey), Array.isArray(releases) ? releases as PatchRelease[] : []]))
-		: {};
-	const patchReleasesByScope: Record<string, PatchRelease[]> = { ...legacyPatchReleasesByScope };
 
 	for (const scopeKey of Object.keys(modeByScopeKey)) {
-		activeByScopeKey[scopeKey] ??= {};
-		lastActiveByScopeKey[scopeKey] ??= { active: false };
 		refreshToggleByScope[scopeKey] ??= false;
-		messageObjectsByScope[scopeKey] ??= new Set<object>();
-		patchReleasesByScope[scopeKey] ??= [];
-	}
-
-	if (legacyActive.active) {
-		lastActiveByScopeKey[currentScopeKey] = legacyActive;
-		if (legacyActive.messageTimestamp !== undefined) {
-			activeByScopeKey[currentScopeKey]![String(legacyActive.messageTimestamp)] = {
-				contentIndex: legacyActive.contentIndex,
-			};
-		}
 	}
 
 	state.currentScopeKey = currentScopeKey;
 	state.modeByScopeKey = modeByScopeKey;
-	state.activeByScopeKey = activeByScopeKey;
-	state.lastActiveByScopeKey = lastActiveByScopeKey;
 	state.refreshToggleByScope = refreshToggleByScope;
-	state.messageScopeByObject = messageScopeByObject;
-	state.messageObjectsByScope = messageObjectsByScope;
-	state.messageScopeByTimestamp = messageScopeByTimestamp;
-	state.patchReleasesByScope = patchReleasesByScope;
-	state.patchRefCount = typeof state.patchRefCount === "number" && Number.isFinite(state.patchRefCount)
-		? state.patchRefCount
-		: 0;
-	state.patchCleanup = typeof state.patchCleanup === "function" ? state.patchCleanup as PatchCleanup : undefined;
-	state.patchInstallPromise = state.patchInstallPromise instanceof Promise ? state.patchInstallPromise as PatchInstallPromise : undefined;
 	return state;
 }
 
@@ -167,15 +65,8 @@ const globalState = (() => {
 	}
 	const created: ThinkingUIGlobalState = {
 		currentScopeKey: DEFAULT_SCOPE_KEY,
-		modeByScopeKey: { [DEFAULT_SCOPE_KEY]: "summary" },
-		activeByScopeKey: { [DEFAULT_SCOPE_KEY]: {} },
-		lastActiveByScopeKey: { [DEFAULT_SCOPE_KEY]: { active: false } },
+		modeByScopeKey: { [DEFAULT_SCOPE_KEY]: "collapsed" },
 		refreshToggleByScope: {},
-		messageScopeByObject: new WeakMap<object, string>(),
-		messageObjectsByScope: { [DEFAULT_SCOPE_KEY]: new Set<object>() },
-		messageScopeByTimestamp: {},
-		patchReleasesByScope: {},
-		patchRefCount: 0,
 	};
 	(globalThis as Record<PropertyKey, unknown>)[STATE_KEY] = created;
 	return created;
@@ -183,23 +74,11 @@ const globalState = (() => {
 
 function ensureScopeState(scopeKey: string): void {
 	if (!(scopeKey in globalState.modeByScopeKey)) {
-		globalState.modeByScopeKey[scopeKey] = "summary";
-	}
-	if (!(scopeKey in globalState.activeByScopeKey)) {
-		globalState.activeByScopeKey[scopeKey] = {};
-	}
-	if (!(scopeKey in globalState.lastActiveByScopeKey)) {
-		globalState.lastActiveByScopeKey[scopeKey] = { active: false };
+		globalState.modeByScopeKey[scopeKey] = "collapsed";
 	}
 	if (!(scopeKey in globalState.refreshToggleByScope)) {
 		globalState.refreshToggleByScope[scopeKey] = false;
 	}
-	if (!(scopeKey in globalState.messageObjectsByScope)) {
-		globalState.messageObjectsByScope[scopeKey] = new Set<object>();
-	}
-	if (!(scopeKey in globalState.patchReleasesByScope)) {
-		globalState.patchReleasesByScope[scopeKey] = [];
-	}
 }
 
 export function getCurrentThinkingScopeKey(): string {
@@ -215,7 +94,7 @@ export function setCurrentThinkingScopeKey(scopeKey: string): void {
 export function getThinkingUIMode(scopeKey?: string): ThinkingUIMode {
 	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
 	ensureScopeState(normalizedScopeKey);
-	return globalState.modeByScopeKey[normalizedScopeKey] ?? "summary";
+	return globalState.modeByScopeKey[normalizedScopeKey] ?? "collapsed";
 }
 
 export function setThinkingUIMode(mode: ThinkingUIMode, scopeKey?: string): void {
@@ -225,62 +104,6 @@ export function setThinkingUIMode(mode: ThinkingUIMode, scopeKey?: string): void
 	globalState.currentScopeKey = normalizedScopeKey;
 }
 
-export function getActiveThinkingState(messageTimestamp?: number, scopeKey?: string): ActiveThinkingState {
-	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
-	ensureScopeState(normalizedScopeKey);
-
-	if (messageTimestamp !== undefined) {
-		const entry = globalState.activeByScopeKey[normalizedScopeKey]![String(messageTimestamp)];
-		if (!entry) return { active: false };
-		return { active: true, messageTimestamp, contentIndex: entry.contentIndex };
-	}
-
-	return { ...globalState.lastActiveByScopeKey[normalizedScopeKey]! };
-}
-
-export function setActiveThinkingState(state: ActiveThinkingState, scopeKey?: string): void {
-	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
-	ensureScopeState(normalizedScopeKey);
-	globalState.lastActiveByScopeKey[normalizedScopeKey] = { ...state };
-
-	if (!state.active || state.messageTimestamp === undefined) {
-		if (state.messageTimestamp !== undefined) {
-			delete globalState.activeByScopeKey[normalizedScopeKey]![String(state.messageTimestamp)];
-		}
-		return;
-	}
-
-	globalState.activeByScopeKey[normalizedScopeKey]![String(state.messageTimestamp)] = {
-		contentIndex: state.contentIndex,
-	};
-}
-
-export function clearActiveThinkingState(messageTimestamp?: number, scopeKey?: string): void {
-	if (messageTimestamp !== undefined) {
-		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
-		ensureScopeState(normalizedScopeKey);
-		delete globalState.activeByScopeKey[normalizedScopeKey]![String(messageTimestamp)];
-		if (globalState.lastActiveByScopeKey[normalizedScopeKey]!.messageTimestamp === messageTimestamp) {
-			globalState.lastActiveByScopeKey[normalizedScopeKey] = { active: false };
-		}
-		return;
-	}
-
-	if (scopeKey !== undefined) {
-		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
-		ensureScopeState(normalizedScopeKey);
-		globalState.activeByScopeKey[normalizedScopeKey] = {};
-		globalState.lastActiveByScopeKey[normalizedScopeKey] = { active: false };
-		return;
-	}
-
-	for (const existingScopeKey of Object.keys(globalState.modeByScopeKey)) {
-		ensureScopeState(existingScopeKey);
-		globalState.activeByScopeKey[existingScopeKey] = {};
-		globalState.lastActiveByScopeKey[existingScopeKey] = { active: false };
-	}
-}
-
 export function nextThinkingRefreshLabel(label: string, scopeKey?: string): string {
 	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
 	ensureScopeState(normalizedScopeKey);
@@ -289,129 +112,16 @@ export function nextThinkingRefreshLabel(label: string, scopeKey?: string): stri
 	return useInvisibleSuffix ? `${label}${LABEL_REFRESH_SUFFIX}` : label;
 }
 
-export function registerThinkingPatchRelease(scopeKey: string, release: PatchRelease): void {
-	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
-	ensureScopeState(normalizedScopeKey);
-	globalState.patchReleasesByScope[normalizedScopeKey]!.push(release);
-}
-
-export function takeThinkingPatchRelease(scopeKey: string): PatchRelease | undefined {
-	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
-	ensureScopeState(normalizedScopeKey);
-	return globalState.patchReleasesByScope[normalizedScopeKey]!.pop();
-}
-
-export function recordThinkingMessageScope(message: object, scopeKey?: string): void {
-	const requestedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
-	ensureScopeState(requestedScopeKey);
-
-	const existingScopeKey = globalState.messageScopeByObject.get(message);
-	const normalizedScopeKey = existingScopeKey ?? requestedScopeKey;
-	ensureScopeState(normalizedScopeKey);
-	if (!existingScopeKey) {
-		globalState.messageScopeByObject.set(message, normalizedScopeKey);
-	}
-	globalState.messageObjectsByScope[normalizedScopeKey]!.add(message);
-
-	const timestamp = typeof (message as { timestamp?: unknown }).timestamp === "number"
-		? (message as { timestamp: number }).timestamp
-		: undefined;
-	if (timestamp !== undefined) {
-		globalState.messageScopeByTimestamp[String(timestamp)] = normalizedScopeKey;
-	}
-}
-
-export function resolveThinkingMessageScope(message: object, fallbackScopeKey?: string): string {
-	const objectScopeKey = globalState.messageScopeByObject.get(message);
-	if (objectScopeKey) {
-		ensureScopeState(objectScopeKey);
-		return objectScopeKey;
-	}
-
-	const timestamp = typeof (message as { timestamp?: unknown }).timestamp === "number"
-		? (message as { timestamp: number }).timestamp
-		: undefined;
-	if (timestamp !== undefined) {
-		const timestampScopeKey = globalState.messageScopeByTimestamp[String(timestamp)];
-		if (timestampScopeKey) {
-			ensureScopeState(timestampScopeKey);
-			return timestampScopeKey;
-		}
-	}
-
-	const normalizedScopeKey = normalizeThinkingScopeKey(fallbackScopeKey ?? globalState.currentScopeKey);
-	ensureScopeState(normalizedScopeKey);
-	return normalizedScopeKey;
-}
-
-export function clearThinkingMessageOwnership(scopeKey?: string): void {
-	if (scopeKey !== undefined) {
-		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
-		ensureScopeState(normalizedScopeKey);
-		const ownedMessages = globalState.messageObjectsByScope[normalizedScopeKey] ?? new Set<object>();
-		for (const message of ownedMessages) {
-			globalState.messageScopeByObject.delete(message);
-		}
-		globalState.messageObjectsByScope[normalizedScopeKey] = new Set<object>();
-		for (const [messageTimestamp, ownerScopeKey] of Object.entries(globalState.messageScopeByTimestamp)) {
-			if (ownerScopeKey === normalizedScopeKey) {
-				delete globalState.messageScopeByTimestamp[messageTimestamp];
-			}
-		}
-		return;
-	}
-
-	globalState.messageScopeByObject = new WeakMap<object, string>();
-	globalState.messageObjectsByScope = { [DEFAULT_SCOPE_KEY]: new Set<object>() };
-	globalState.messageScopeByTimestamp = {};
-}
-
 export function resetThinkingUIViewState(scopeKey?: string): void {
 	if (scopeKey !== undefined) {
 		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
 		globalState.currentScopeKey = normalizedScopeKey;
-		globalState.modeByScopeKey[normalizedScopeKey] = "summary";
+		globalState.modeByScopeKey[normalizedScopeKey] = "collapsed";
 		globalState.refreshToggleByScope[normalizedScopeKey] = false;
-		globalState.activeByScopeKey[normalizedScopeKey] = {};
-		globalState.lastActiveByScopeKey[normalizedScopeKey] = { active: false };
-		clearThinkingMessageOwnership(normalizedScopeKey);
 		return;
 	}
 
 	globalState.currentScopeKey = DEFAULT_SCOPE_KEY;
-	globalState.modeByScopeKey = { [DEFAULT_SCOPE_KEY]: "summary" };
-	globalState.activeByScopeKey = { [DEFAULT_SCOPE_KEY]: {} };
-	globalState.lastActiveByScopeKey = { [DEFAULT_SCOPE_KEY]: { active: false } };
+	globalState.modeByScopeKey = { [DEFAULT_SCOPE_KEY]: "collapsed" };
 	globalState.refreshToggleByScope = {};
-	clearThinkingMessageOwnership();
-}
-
-export function getPatchRefCount(): number {
-	return globalState.patchRefCount;
-}
-
-export function incrementPatchRefCount(): number {
-	globalState.patchRefCount += 1;
-	return globalState.patchRefCount;
-}
-
-export function decrementPatchRefCount(): number {
-	globalState.patchRefCount = Math.max(0, globalState.patchRefCount - 1);
-	return globalState.patchRefCount;
-}
-
-export function getPatchCleanup(): PatchCleanup | undefined {
-	return globalState.patchCleanup;
-}
-
-export function setPatchCleanup(cleanup: PatchCleanup | undefined): void {
-	globalState.patchCleanup = cleanup;
-}
-
-export function getPatchInstallPromise(): PatchInstallPromise | undefined {
-	return globalState.patchInstallPromise;
-}
-
-export function setPatchInstallPromise(installPromise: PatchInstallPromise | undefined): void {
-	globalState.patchInstallPromise = installPromise;
 }

package/types.ts

@@ -51,12 +51,6 @@ export interface DerivedThinkingStep {
 	hasExplicitSuccess?: boolean;
 }
 
-export interface ActiveThinkingState {
-	messageTimestamp?: number;
-	contentIndex?: number;
-	active: boolean;
-}
-
 export interface ThinkingThemeLike {
 	fg(color: string, text: string): string;
 	bold(text: string): string;