mirror of
https://github.com/fabro-sh/fabro.git
synced 2026-09-14 23:22:51 +00:00
b196a97ac4
## Summary
Implements the React Effects Policy by creating the approved hook
surface in `hooks/effects.ts` and migrating a broad set of direct
`useEffect` calls across the codebase to either purpose-named hooks or
non-effect patterns.
### Plan Summary
- Add `hooks/effects.ts` exporting `useMountEffect`, `useInterval`,
`useTimeout`, `useDebouncedValue`, `useWindowEvent`, `useDocumentEvent`,
`useDocumentTitle`, `useMediaQuery`, `useLocationHash`, and
`useResizeObserver`
- Extract large imperative effects into purpose-named hooks:
`useTerminalSession`, `useFloatingTooltipMeasurements`,
`useAnnotatedRunGraphSvg`, `useInstallEffects`, and others
- Move install session fetch from a component effect into a SWR query
(`install-query.ts`)
- Replace `useEffect` + `useState` state-derivation patterns with
render-time computation or ref callbacks
- Replace `AskFabroLayoutProvider`/`useAskFabroLayout` context with a
prop callback
## What changed and why
**`hooks/effects.ts`** — the new approved primitive surface. All
internal `useEffect` calls here are intentional; the hooks expose the
*external system* they manage rather than leaking `useEffect` to
component code. `useMediaQuery` and `useLocationHash` use
`useSyncExternalStore` instead of effect + state.
**`useTerminalSession`** — the largest extraction. The 130-line
xterm/WebSocket/ResizeObserver setup block moves from
`terminal-view.tsx` into its own hook, which now owns the `terminalRef`,
`fitRef`, and `socketRef` that previously cluttered the component.
`TerminalConnectionError` and `ConnectionStatus` types are exported from
the hook.
**`useFloatingTooltipMeasurements`** — extracts the `useLayoutEffect` +
ResizeObserver + window resize listener out of `FloatingTooltip`. The
`FloatingTooltipSize` type moves with it so consumers don't need to
import from the component.
**`useInstallSessionQuery` + `useInstallEffects`** — the install session
fetch moves from a component effect to SWR (`install-query.ts`). The
three remaining install effects (token URL scrubbing, GitHub error URL
scrubbing, health-poll restart) move into
`hooks/use-install-effects.ts`. The root-redirect effect is replaced
with a render-time `<Navigate>` gate. The `SessionState` discriminant
now carries `token` so stale query results can be discarded without an
effect chain.
**`SelectionCheckbox`** — `useEffect` setting `input.indeterminate` is
replaced with a ref callback, which runs synchronously after the node is
attached and avoids a stale-frame flash.
**`event-debug.tsx`** — the manual `window.addEventListener("keydown",
...)` pattern is replaced with `useWindowEvent`, removing the
`react-doctor-disable` suppression comments.
**`run-waterfall.tsx`** — the local `useTickingNow` is deleted;
`RunWaterfall` now calls the shared `useTickingNow` from `lib/time` with
the new `active` parameter signature.
**`toast.test.tsx`** — `useEffect(() => onReady?.(api), ...)` in the
test helper is replaced with a direct call during render, which is valid
because `onReady` has no side effects that React cares about.
**`AskFabroSidebar`** — `setIsResizing` from the layout context is
replaced with an `onResizeActiveChange` prop, removing the
`useAskFabroLayout` call and the hidden context coupling from the
sidebar.
### Fabro Details
<details>
<summary>Ran 3 stages in 114m 5s for $95.71</summary>
| Stage | Duration | Cost | Retries |
|---|---|---|---|
| start | 0s | – | 0 |
| work | 103m 3s | $80.42 | 0 |
| audit | 10m 19s | $15.29 | 0 |
| **Total** | **114m 5s** | **$95.71** | **0** |
</details>
<details>
<summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary>
```dot
digraph Goal {
graph [
goal="Complete the user-provided goal",
rankdir=LR,
max_node_visits=30
]
start [shape=Mdiamond, label="Start"]
exit [shape=Msquare, label="Exit"]
work [
label="Work",
thread_id="goal",
fidelity="full",
max_visits=12,
model="gpt-55",
reasoning_effort="xhigh",
prompt="@prompts/continue.md"
]
audit [
label="Completion Audit",
thread_id="goal",
fidelity="full",
goal_gate=true,
retry_target="work",
output_schema="routing",
output_retries=2,
max_visits=12,
model="gpt-55",
reasoning_effort="xhigh",
prompt="@prompts/audit.md"
]
start -> work -> audit
audit -> exit [label="Done", condition="outcome=succeeded"]
audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"]
audit -> work [label="No clear verdict"]
}
```
</details>
⚒️ Generated with [Fabro](https://fabro.sh)
---------
Co-authored-by: Fabro <noreply@fabro.sh>
Co-authored-by: Bryan Helmkamp <bryan@brynary.com>
107 lines
3.1 KiB
TypeScript
107 lines
3.1 KiB
TypeScript
import {
|
|
type CSSProperties,
|
|
type ReactNode,
|
|
} from "react";
|
|
import { createPortal } from "react-dom";
|
|
import {
|
|
useFloatingTooltipMeasurements,
|
|
type FloatingTooltipSize,
|
|
} from "../hooks/use-floating-tooltip-measurements";
|
|
|
|
type FloatingTooltipPlacement = "top" | "bottom";
|
|
const VIEWPORT_MARGIN = 12;
|
|
const OFFSET = 8;
|
|
const DEFAULT_CLASS_NAME =
|
|
"whitespace-nowrap rounded-md bg-panel-alt px-2.5 py-1 text-xs text-fg shadow-lg outline-1 -outline-offset-1 outline-line-strong";
|
|
|
|
function clamp(value: number, min: number, max: number): number {
|
|
if (max < min) return (min + max) / 2;
|
|
return Math.min(Math.max(value, min), max);
|
|
}
|
|
|
|
function resolvePlacement(
|
|
rect: DOMRect,
|
|
placement: FloatingTooltipPlacement,
|
|
height: number,
|
|
viewportHeight: number,
|
|
): FloatingTooltipPlacement {
|
|
if (height <= 0) return placement;
|
|
|
|
const fitsTop = rect.top - OFFSET - height >= VIEWPORT_MARGIN;
|
|
const fitsBottom = rect.bottom + OFFSET + height <= viewportHeight - VIEWPORT_MARGIN;
|
|
|
|
if (placement === "top") {
|
|
return fitsTop || !fitsBottom ? "top" : "bottom";
|
|
}
|
|
return fitsBottom || !fitsTop ? "bottom" : "top";
|
|
}
|
|
|
|
function floatingStyle(
|
|
rect: DOMRect,
|
|
placement: FloatingTooltipPlacement,
|
|
size: FloatingTooltipSize,
|
|
viewport: FloatingTooltipSize,
|
|
): CSSProperties {
|
|
const viewportWidth = viewport.width;
|
|
const viewportHeight = viewport.height;
|
|
const centerX = rect.left + rect.width / 2;
|
|
const availableWidth = Math.max(0, viewportWidth - VIEWPORT_MARGIN * 2);
|
|
const width = size.width > 0 ? Math.min(size.width, availableWidth) : 0;
|
|
const halfWidth = width / 2;
|
|
const minCenter = VIEWPORT_MARGIN + halfWidth;
|
|
const maxCenter = viewportWidth - VIEWPORT_MARGIN - halfWidth;
|
|
const left = width > 0
|
|
? clamp(centerX, minCenter, maxCenter)
|
|
: clamp(centerX, VIEWPORT_MARGIN, viewportWidth - VIEWPORT_MARGIN);
|
|
const resolvedPlacement = resolvePlacement(rect, placement, size.height, viewportHeight);
|
|
|
|
if (resolvedPlacement === "top") {
|
|
const top = size.height > 0
|
|
? Math.max(VIEWPORT_MARGIN, rect.top - OFFSET - size.height)
|
|
: rect.top - OFFSET;
|
|
return {
|
|
left,
|
|
maxWidth: availableWidth,
|
|
top,
|
|
transform: size.height > 0 ? "translateX(-50%)" : "translate(-50%, -100%)",
|
|
};
|
|
}
|
|
|
|
const top = size.height > 0
|
|
? Math.min(viewportHeight - VIEWPORT_MARGIN - size.height, rect.bottom + OFFSET)
|
|
: rect.bottom + OFFSET;
|
|
return {
|
|
left,
|
|
maxWidth: availableWidth,
|
|
top: Math.max(VIEWPORT_MARGIN, top),
|
|
transform: "translateX(-50%)",
|
|
};
|
|
}
|
|
|
|
export function FloatingTooltip({
|
|
rect,
|
|
placement,
|
|
children,
|
|
className = DEFAULT_CLASS_NAME,
|
|
}: {
|
|
rect: DOMRect;
|
|
placement: FloatingTooltipPlacement;
|
|
children: ReactNode;
|
|
className?: string;
|
|
}) {
|
|
const { ref, size, viewport } = useFloatingTooltipMeasurements();
|
|
|
|
if (typeof document === "undefined") return null;
|
|
|
|
return createPortal(
|
|
<div
|
|
ref={ref}
|
|
role="tooltip"
|
|
style={floatingStyle(rect, placement, size, viewport)}
|
|
className={`pointer-events-none fixed z-50 ${className}`}
|
|
>
|
|
{children}
|
|
</div>,
|
|
document.body,
|
|
);
|
|
}
|