AI media harness for planning, generating, and editing locally
TypeScript
/* Splitter + usePaneSize — resizable panes.
A 4px hit area centred on a 1px line that turns accent under the mouse and
while dragging. role="separator" with aria-valuenow/min/max; arrow keys
move it 8px (Shift: 32px), Home/End jump to the limits, double-click
resets. Sizes persist in localStorage under "slopus.pane.<key>".
// GeneratorView: a side pane at --pane-side-default (340px), 280-560px
const inspectorPane = usePaneSize("generator.inspector", 340, { min: 280, max: 560 });
<div className="generator-view" style={inspectorPane.style}> // sets --pane-generator-inspector
<main />
<Splitter {...inspectorPane.splitterProps} reverse aria-label="Resize inspector" aria-controls="generator-inspector" />
<aside id="generator-inspector" />
</div>
.generator-view { grid-template-columns: minmax(280px, 1fr) auto minmax(280px, var(--pane-generator-inspector)); }
`reverse` is for a pane on the right (or bottom) of the splitter: dragging
towards it makes it smaller. Orientation "vertical" (default) is a vertical
line between columns; "horizontal" is a horizontal line between rows. */
import { useCallback, useEffect, useMemo, useRef, useState, type CSSProperties, type KeyboardEvent, type PointerEvent } from "react";
import { cx } from "./internal";
export interface PaneSizeOptions {
min?: number;
max?: number;
/** CSS custom property name. Default `--pane-<key with dots → dashes>`. */
cssVar?: string;
/** Default true. */
persist?: boolean;
}
export interface SplitterValueProps {
value: number;
min: number;
max: number;
onChange: (size: number) => void;
onReset?: () => void;
}
export interface PaneSize {
size: number;
setSize: (size: number) => void;
reset: () => void;
min: number;
max: number;
cssVar: string;
/** Spread on the grid container. */
style: CSSProperties;
/** Spread on the <Splitter>. */
splitterProps: SplitterValueProps;
}
const STORAGE_PREFIX = "slopus.pane.";
function readStored(key: string): number | undefined {
try {
const raw = localStorage.getItem(STORAGE_PREFIX + key);
if (raw === null) return undefined;
const value = Number(raw);
return Number.isFinite(value) ? value : undefined;
} catch {
return undefined;
}
}
export function usePaneSize(key: string, defaultSize: number, options: PaneSizeOptions = {}): PaneSize {
const min = options.min ?? 0;
const max = options.max ?? Number.MAX_SAFE_INTEGER;
const persist = options.persist !== false;
const cssVar = options.cssVar ?? `--pane-${key.replace(/[^a-zA-Z0-9-]+/g, "-")}`;
const clampSize = useCallback((value: number) => Math.round(Math.min(max, Math.max(min, value))), [min, max]);
const [size, setRaw] = useState(() => Math.round((persist ? readStored(key) : undefined) ?? defaultSize));
useEffect(() => {
if (!persist) return;
try { localStorage.setItem(STORAGE_PREFIX + key, String(size)); } catch { /* storage unavailable */ }
}, [key, size, persist]);
const setSize = useCallback((value: number) => setRaw(clampSize(value)), [clampSize]);
const reset = useCallback(() => setRaw(clampSize(defaultSize)), [clampSize, defaultSize]);
/* The limits may move (a max that follows the window width). What is shown
is clamped to the limits of the moment; the stored preference is not
touched, so a pane squeezed by a narrow window comes back to its size
when the window grows again. */
const shown = clampSize(size);
return useMemo(() => ({
size: shown,
setSize,
reset,
min,
max,
cssVar,
style: { [cssVar]: `${shown}px` } as CSSProperties,
splitterProps: { value: shown, min, max, onChange: setSize, onReset: reset },
}), [shown, setSize, reset, min, max, cssVar]);
}
export interface SplitterProps extends SplitterValueProps {
/** "vertical" = a vertical line between columns (default); "horizontal" = between rows. */
orientation?: "vertical" | "horizontal";
/** The pane being sized is after the splitter (right / below). */
reverse?: boolean;
"aria-label"?: string;
/** Id of the pane being sized. */
"aria-controls"?: string;
className?: string;
disabled?: boolean;
/** Keyboard step in px (default 8; Shift ×4). */
step?: number;
}
export function Splitter({
value, min, max, onChange, onReset, orientation = "vertical", reverse, className, disabled, step = 8, ...aria
}: SplitterProps) {
const drag = useRef<{ start: number; size: number; pointer: number } | null>(null);
const [dragging, setDragging] = useState(false);
const vertical = orientation === "vertical";
const clamp = (next: number) => Math.min(max, Math.max(min, next));
const onPointerDown = (event: PointerEvent<HTMLDivElement>) => {
if (disabled || event.button !== 0) return;
event.preventDefault();
event.currentTarget.setPointerCapture?.(event.pointerId);
drag.current = { start: vertical ? event.clientX : event.clientY, size: value, pointer: event.pointerId };
setDragging(true);
};
const onPointerMove = (event: PointerEvent<HTMLDivElement>) => {
if (!drag.current) return;
const delta = (vertical ? event.clientX : event.clientY) - drag.current.start;
const next = clamp(drag.current.size + (reverse ? -delta : delta));
if (next !== value) onChange(next);
};
const end = (event: PointerEvent<HTMLDivElement>) => {
if (!drag.current) return;
event.currentTarget.releasePointerCapture?.(drag.current.pointer);
drag.current = null;
setDragging(false);
};
const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
if (disabled) return;
const amount = event.shiftKey ? step * 4 : step;
const grow = reverse ? -amount : amount;
let next: number | undefined;
if (vertical && event.key === "ArrowLeft") next = value - grow;
else if (vertical && event.key === "ArrowRight") next = value + grow;
else if (!vertical && event.key === "ArrowUp") next = value - grow;
else if (!vertical && event.key === "ArrowDown") next = value + grow;
else if (event.key === "Home") next = min;
else if (event.key === "End") next = max;
else if (event.key === "Enter" && onReset) { event.preventDefault(); onReset(); return; }
if (next === undefined) return;
event.preventDefault();
next = clamp(next);
if (next !== value) onChange(next);
};
return (
<div
role="separator"
tabIndex={disabled ? -1 : 0}
aria-orientation={orientation}
aria-valuenow={Math.round(value)}
aria-valuemin={min}
aria-valuemax={max === Number.MAX_SAFE_INTEGER ? undefined : max}
aria-label={aria["aria-label"]}
aria-controls={aria["aria-controls"]}
aria-disabled={disabled || undefined}
className={cx("ui-splitter", `ui-splitter--${orientation}`, dragging && "ui-splitter--dragging", className)}
onPointerDown={onPointerDown}
onPointerMove={onPointerMove}
onPointerUp={end}
onPointerCancel={end}
onLostPointerCapture={end}
onDoubleClick={() => { if (!disabled) onReset?.(); }}
onKeyDown={onKeyDown}
/>
);
}