Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

7.0 KB
Raw Blame
import { useEffect, useLayoutEffect, useRef, useState } from 'react';
import type { JSX } from 'react';
import type { ProjectEntry } from '../provider/rpc-schemas';
import { projectSwitcherStrings as text } from './project-switcher-strings';
import { projectPickerPlacement } from './project-picker-placement';
import { RefreshControl, useRefreshFeedback } from '../ui/refresh/refresh-feedback';
import './project-switcher.css';

interface ProjectSwitcherProps {
    currentProject: string;
    listProjects: () => Promise<readonly ProjectEntry[]>;
    onSelectProject: (name: string) => void;
    onAddProject: () => void;
    indexActivity?: { name: string; status: 'indexing' | 'done' | 'error' };
}

export default function ProjectSwitcher(props: ProjectSwitcherProps): JSX.Element {
    const [open, setOpen] = useState(false);
    const [entries, setEntries] = useState<readonly ProjectEntry[]>([]);
    const [status, setStatus] = useState<'loading' | 'ready' | 'error'>('loading');
    const [revision, setRevision] = useState(0);
    // Every reading of the list counts, also the one an opening starts; the Refresh status speaks about one of them (review of K42).
    const [reads, setReads] = useState(0);
    const [placement, setPlacement] = useState({ top: 64, left: 12, width: 370, maxHeight: 520 });
    const disclosure = useRef<HTMLDetailsElement>(null);
    const trigger = useRef<HTMLElement>(null);
    const close = (restoreFocus = false): void => {
        setOpen(false);
        if (restoreFocus) trigger.current?.focus();
    };

    useLayoutEffect(() => {
        if (!open) return;
        const reposition = (): void => {
            const bounds = trigger.current?.getBoundingClientRect();
            if (bounds) setPlacement(projectPickerPlacement(bounds, { width: window.innerWidth, height: window.innerHeight }));
        };
        reposition();
        const observer = typeof ResizeObserver === 'undefined' ? undefined : new ResizeObserver(reposition);
        const header = disclosure.current?.closest('.atlas-header') ?? trigger.current;
        if (header) observer?.observe(header);
        window.addEventListener('resize', reposition);
        window.addEventListener('scroll', reposition, true);
        return () => {
            observer?.disconnect();
            window.removeEventListener('resize', reposition);
            window.removeEventListener('scroll', reposition, true);
        };
    }, [open]);

    useEffect(() => {
        if (!open) return;
        let current = true;
        setStatus('loading');
        setReads(value => value + 1);
        void Promise.resolve().then(props.listProjects).then(
            (projects) => {
                if (!current) return;
                setEntries(projects);
                setStatus('ready');
            },
            () => { if (current) setStatus('error'); },
        );
        return () => { current = false; };
    }, [open, props.listProjects, revision]);

    useEffect(() => {
        if (!open) return;
        const outside = (event: PointerEvent): void => {
            if (event.target instanceof Node && !disclosure.current?.contains(event.target)) setOpen(false);
        };
        document.addEventListener('pointerdown', outside);
        return () => document.removeEventListener('pointerdown', outside);
    }, [open]);

    /*
     * Review of K42: "Refresh projects" showed "Loading projects..." for about
     * 150 ms and then the same list. Now it says that it runs, then when and
     * whether the list changed; a failure only gets its time, the list area
     * says what failed and offers Try again.
     */
    const refresh = useRefreshFeedback({ key: String(reads), settled: status !== 'loading',
        value: entries.map(entry => [entry.name, entry.root_path]), error: status === 'error' ? '' : undefined });

    const projects = Array.from(new Map(entries.map(entry => [entry.name, entry])).values())
        .filter(entry => entry.name.length > 0)
        .sort((left, right) => Number(right.name === props.currentProject) - Number(left.name === props.currentProject)
            || left.name.localeCompare(right.name));

    return <details ref={disclosure} open={open} className="atlas-project-switcher"
        onKeyDown={(event) => {
            if (event.key !== 'Escape' || !open) return;
            event.preventDefault();
            event.stopPropagation();
            close(true);
        }}
        onBlur={(event) => {
            if (event.relatedTarget instanceof Node && !event.currentTarget.contains(event.relatedTarget)) close();
        }}>
        <summary ref={trigger} aria-label={text.switchProject(props.currentProject || text.choose)}
            title={props.currentProject || text.choose}
            onClick={(event) => {
                event.preventDefault();
                if (!open) setStatus('loading');
                setOpen(value => !value);
            }}>
            <span className="atlas-project-switcher-label">{text.project}</span>
            <span className="atlas-project-switcher-name">{props.currentProject || text.choose}</span>
            <span aria-hidden="true">⌄</span>
        </summary>
        {open && <div className="atlas-project-picker" style={placement}>
            <div className="atlas-project-results" aria-busy={status === 'loading'}>
                {status === 'loading' && <p role="status">{text.loading}</p>}
                {status === 'error' && <div role="status"><p>{text.failed}</p>
                    <button type="button" onClick={() => setRevision(value => value + 1)}>{text.retry}</button>
                </div>}
                {status === 'ready' && projects.length === 0 && <p role="status">{text.empty}</p>}
                {status === 'ready' && <ul>{projects.map(entry => <li key={entry.name}>
                    <button type="button" aria-current={entry.name === props.currentProject ? 'true' : undefined}
                        onClick={() => {
                            close(true);
                            if (entry.name !== props.currentProject) props.onSelectProject(entry.name);
                        }}>
                        <span className="atlas-project-result-name">{entry.name}
                            {entry.name === props.currentProject && <small>{text.current}</small>}</span>
                        {entry.root_path && <span className="atlas-project-result-path">{entry.root_path}</span>}
                    </button>
                </li>)}</ul>}
            </div>
            {props.indexActivity && <button type="button" className="atlas-project-index-activity"
                onClick={() => { close(true); props.onAddProject(); }}>
                <span>{text.indexActivity(props.indexActivity.status)}</span><span>{props.indexActivity.name}</span>
            </button>}
            <footer>
                <button type="button" onClick={() => { close(true); props.onAddProject(); }}>{text.add}</button>
                <RefreshControl labels={text.refreshFeedback} feedback={refresh.feedback} onRefresh={() => { refresh.begin(); setRevision(value => value + 1); }} />
            </footer>
        </div>}
    </details>;
}