@adecore/database 0.38.0 → 0.40.0

package/src/explorer/DatabaseExplorer.tsx

@@ -100,6 +100,7 @@ export function DatabaseExplorer({
         versions: loads.versions,
         folders: (connectionId: string) => folders?.[connectionId] ?? []
     };
+
     const rows = flattenTree({ ...input, filter });
     const stop = tabStop(rows, activeKey, selectedKey);
 
@@ -118,15 +119,19 @@ export function DatabaseExplorer({
 
     const setOpen = (key: string, open: boolean): void => {
         const folder = startsOpen(key);
+
         const toggle = (current: ReadonlySet<string>): ReadonlySet<string> => {
             const next = new Set(current);
+
             if (open !== folder) {
                 next.add(key);
             } else {
                 next.delete(key);
             }
+
             return next;
         };
+
         (folder ? setCollapsed : setExpanded)(toggle);
     };
 
@@ -138,11 +143,13 @@ export function DatabaseExplorer({
         if (value === undefined) {
             setOwn(selection);
         }
+
         onValueChange?.(selection);
     };
 
     const pick = (row: TreeRow): void => {
         const selection = selectionOf(row);
+
         if (selection !== null) {
             select(selection);
         }
@@ -152,12 +159,16 @@ export function DatabaseExplorer({
     const open = (row: TreeRow, preview = false): void => {
         if (row.kind === 'appItem') {
             row.item.onOpen?.({ preview });
+
             return;
         }
+
         const ref = openedTableOf(row);
+
         if (ref === null) {
             return;
         }
+
         pick(row);
         const tableKind = row.kind === 'table' && row.ref === ref ? row.table.kind : tableKindIn(loads.tables(ref.connectionId, ref.schema), ref.table);
         act?.({ kind: 'open-table', ref, view: 'data', ...(tableKind === undefined ? {} : { tableKind }), ...(openOnClick ? { preview } : {}) });
@@ -170,6 +181,7 @@ export function DatabaseExplorer({
             case 'entry':
             case 'appItem':
                 open(row);
+
                 break;
             case 'connection':
             case 'schema':
@@ -178,9 +190,11 @@ export function DatabaseExplorer({
             case 'appFolder':
                 pick(row);
                 toggle(row);
+
                 break;
             case 'error':
                 loads.reset(row.retry);
+
                 break;
         }
     };
@@ -189,16 +203,21 @@ export function DatabaseExplorer({
         if ((e.target as HTMLElement).tagName === 'BUTTON') {
             return;
         }
+
         const action = navigate(rows, activeKey ?? stop, e.key);
+
         if (action === null) {
             return;
         }
+
         e.preventDefault();
+
         if (action.type === 'focus') {
             focusAfterRender.current = true;
             setActiveKey(action.key);
         } else if (action.type === 'activate') {
             const row = rows.find((candidate) => candidate.key === action.key);
+
             if (row !== undefined) {
                 activate(row);
             }
@@ -212,14 +231,19 @@ export function DatabaseExplorer({
         if (pressedInPopup()) {
             return;
         }
+
         setActiveKey(row.key);
+
         if (openOnClick && (row.kind === 'table' || row.kind === 'appItem')) {
             if (count <= 1) {
                 open(row, true);
             }
+
             return;
         }
+
         pick(row);
+
         if (row.kind !== 'table' && isExpandable(row)) {
             toggle(row);
         } else if (row.kind === 'error') {
@@ -236,6 +260,7 @@ export function DatabaseExplorer({
     const finish = (done: TableRequest, to: string | undefined): void => {
         setRequest(null);
         const { connectionId, schema, table } = done.ref;
+
         if (selected?.connectionId === connectionId && selected.schema === schema && selected.table === table) {
             select(to === undefined ? { connectionId, schema } : { connectionId, schema, table: to });
         }
@@ -243,6 +268,7 @@ export function DatabaseExplorer({
 
     const connectionOf = (row: TreeRow): Connection | undefined => {
         const selection = selectionOf(row);
+
         return selection === null ? undefined : connections.find((entry) => entry.id === selection.connectionId);
     };
 
@@ -250,14 +276,17 @@ export function DatabaseExplorer({
 
     const renderRow = (row: TreeRow, index: number): ReactNode => {
         const connection = connectionOf(row);
+
         const menu =
             row.kind === 'appItem' ? (
                 (row.item.menu ?? null)
             ) : connection !== undefined && hasMenu(row) ? (
                 <RowMenu row={row} connection={connection} onRefresh={loads.reset} onDisconnect={disconnect} onRequest={setRequest} />
             ) : null;
+
         const selectedRow = isSelected(row);
         const draggable = row.kind === 'table' && onTableDragStart !== undefined;
+
         const props = {
             level: row.level,
             selected: selectedRow,
@@ -288,7 +317,9 @@ export function DatabaseExplorer({
                 }
             }
         };
+
         const content = <RowContent row={row} onToggle={isExpandable(row) ? () => toggle(row) : undefined} />;
+
         if (menu === null) {
             return (
                 <Tree.Row key={row.key} {...props}>
@@ -296,6 +327,7 @@ export function DatabaseExplorer({
                 </Tree.Row>
             );
         }
+
         return (
             <ContextMenu.Root key={row.key}>
                 <ContextMenu.Trigger render={<Tree.Row {...props} />}>{content}</ContextMenu.Trigger>
@@ -339,6 +371,7 @@ export function DatabaseExplorer({
 
 function RowContent({ row, onToggle }: { row: TreeRow; onToggle?: () => void }) {
     const { t } = useTranslation('database');
+
     switch (row.kind) {
         case 'connection':
             return (
@@ -446,6 +479,7 @@ const EMPTY_WORDS = { schemas: 'explorer.noSchemas', tables: 'explorer.noTables'
 function SchemaCount({ shown, total }: { shown: number; total: number }) {
     const { t } = useTranslation('database');
     const counts = { shown: formatNumber(shown), total: formatNumber(total) };
+
     return (
         <Tooltip label={t('explorer.schemaCountHint', { count: total, ...counts })}>
             <span className="shrink-0 text-text-faint tabular-nums">{t('explorer.schemaCount', counts)}</span>
@@ -458,6 +492,7 @@ const ENTRY_ICON_SLOT = 'inline-flex size-4 shrink-0 items-center justify-center
 
 function ColumnIcon(keys: ColumnKeys) {
     const { t } = useTranslation('database');
+
     if (!keys.primaryKey && !keys.foreignKey) {
         return (
             <span className={ENTRY_ICON_SLOT}>
@@ -465,6 +500,7 @@ function ColumnIcon(keys: ColumnKeys) {
             </span>
         );
     }
+
     return (
         <Tooltip label={t(keyLabelOf(keys))}>
             <span className={ENTRY_ICON_SLOT}>
@@ -478,11 +514,13 @@ function ColumnIcon(keys: ColumnKeys) {
 function EntryContent({ row }: { row: EntryRow }) {
     const { t } = useTranslation('database');
     const { entry } = row;
+
     const icon = (glyph: LucideIcon, className: string): ReactNode => (
         <span className={ENTRY_ICON_SLOT}>
             <Icon icon={glyph} size={14} className={className} />
         </span>
     );
+
     switch (entry.type) {
         case 'key':
             return (
@@ -496,6 +534,7 @@ function EntryContent({ row }: { row: EntryRow }) {
         case 'foreignKey': {
             const { foreignKey } = entry;
             const columns = foreignKey.columns.join(', ');
+
             return (
                 <>
                     <Tree.ChevronSlot />
@@ -544,6 +583,7 @@ function EntryContent({ row }: { row: EntryRow }) {
 
 function ErrorContent({ row }: { row: ErrorRow }) {
     const { t } = useTranslation('database');
+
     return (
         <>
             <Tree.ChevronSlot />

package/src/explorer/RowMenu.tsx

@@ -47,6 +47,7 @@ export function RowMenu({ row, connection, onRefresh, onDisconnect, onRequest }:
 
     const copyDdl = async (ref: TableRef): Promise<void> => {
         const structure = await client.session(connection).structure(ref.schema, ref.table);
+
         if (structure.ddl !== null) {
             copyText(structure.ddl);
         }
@@ -64,6 +65,7 @@ export function RowMenu({ row, connection, onRefresh, onDisconnect, onRequest }:
 
     const tableGroups = (ref: TableRef, kind: TableKind): ReactNode[][] => {
         const request = (change: TableRequest['change']) => (): void => onRequest({ change, connection, ref, kind });
+
         return [
             [
                 actionItem('open-data', Table, t('explorer.openData'), { kind: 'open-table', ref, view: 'data', tableKind: kind }),

package/src/explorer/TableDialog.tsx

@@ -32,13 +32,16 @@ export function TableDialog({ request, onClose, onDone }: TableDialogProps) {
         const dialect = dialectOf(await session.server());
         const { results } = await session.execute(statementOf(dialect, change, ref, kind, to));
         const failed = results.find((result) => result.kind === 'error');
+
         if (failed?.kind === 'error') {
             throw new Error(failed.error.message);
         }
+
         // The client tells its listeners after a `RENAME`, a `DROP` and a `TRUNCATE`, but not after a SQLite emptying, which is a `DELETE FROM`.
         if (change === 'truncate' && dialect.engine === 'sqlite') {
             client.notifySchemaChange({ connectionId: ref.connectionId, schema: ref.schema });
         }
+
         onDone(request, to);
     };
 
@@ -46,13 +49,16 @@ export function TableDialog({ request, onClose, onDone }: TableDialogProps) {
         if (change === 'rename') {
             if (typed === ref.table) {
                 onClose();
+
                 return;
             }
+
             await run(typed);
         } else if (change === 'drop') {
             if (typed !== ref.table) {
                 throw new Error(t('explorer.drop.mismatch'));
             }
+
             await run();
         } else {
             await run();

package/src/explorer/expansion.ts

@@ -14,15 +14,20 @@ export const expansionKey = (connectionId: string): string => `database:explorer
 /* Reads what `serializeExpansion` wrote. Anything that does not fit gives nothing open and no folder closed. */
 export const parseExpansion = (raw: string | null, connectionId: string): Expansion => {
     const none: Expansion = { expanded: new Set(), collapsed: new Set() };
+
     if (raw === null) {
         return none;
     }
+
     try {
         const parsed: unknown = JSON.parse(raw);
+
         if (typeof parsed !== 'object' || parsed === null || (parsed as { version?: unknown }).version !== VERSION) {
             return none;
         }
+
         const { expanded, collapsed } = parsed as { expanded?: unknown; collapsed?: unknown };
+
         const own = (keys: unknown, folders: boolean): Set<string> =>
             new Set(
                 Array.isArray(keys)
@@ -32,6 +37,7 @@ export const parseExpansion = (raw: string | null, connectionId: string): Expans
                       )
                     : []
             );
+
         return { expanded: own(expanded, false), collapsed: own(collapsed, true) };
     } catch {
         return none;
@@ -41,7 +47,9 @@ export const parseExpansion = (raw: string | null, connectionId: string): Expans
 /* What a connection has open as the text to store, or `null` when everything is as it starts, which removes the key. */
 export const serializeExpansion = (connectionId: string, { expanded, collapsed }: Expansion): string | null => {
     const own = (keys: ReadonlySet<string>): string[] => [...keys].filter((key) => connectionOfKey(key) === connectionId).sort();
+
     const open = own(expanded);
     const closed = own(collapsed);
+
     return open.length === 0 && closed.length === 0 ? null : JSON.stringify({ version: VERSION, expanded: open, collapsed: closed });
 };

package/src/explorer/tree.ts

@@ -35,31 +35,45 @@ export interface LoadTarget {
 const SEPARATOR = '\u0000';
 
 export const connectionKey = (connectionId: string): string => `c:${connectionId}`;
+
 export const schemaKey = (connectionId: string, schema: string): string => `s:${connectionId}${SEPARATOR}${schema}`;
+
 export const folderKey = (connectionId: string, schema: string, group: TableKind): string => `f:${connectionId}${SEPARATOR}${schema}${SEPARATOR}${group}`;
+
 export const tableKey = (ref: TableRef): string => `t:${ref.connectionId}${SEPARATOR}${ref.schema}${SEPARATOR}${ref.table}`;
+
 /* The folders of a table, in the order they come under it. */
 export const PARTS = ['columns', 'keys', 'foreignKeys', 'indexes', 'checks', 'triggers'] as const;
+
 export type TablePart = (typeof PARTS)[number];
+
 export const partKey = (ref: TableRef, part: TablePart): string => `p:${ref.connectionId}${SEPARATOR}${ref.schema}${SEPARATOR}${ref.table}${SEPARATOR}${part}`;
+
 /* A folder of a schema, and the columns of a table, are open until the person closes them; everything else is closed until they open it. */
 export const startsOpen = (key: string): boolean => key.startsWith('f:') || (key.startsWith('p:') && key.endsWith(`${SEPARATOR}columns`));
+
 /* The connection a key of a connection, schema, folder or table belongs to. */
 export const connectionOfKey = (key: string): string => {
     const rest = key.slice(2);
     const end = rest.indexOf(SEPARATOR);
+
     return end === -1 ? rest : rest.slice(0, end);
 };
+
 export const columnKey = (ref: TableRef, column: string): string => `${tableKey(ref)}${SEPARATOR}${column}`;
+
 /* A folder of the app's own under a connection, and an item in it. */
 export const appFolderKey = (connectionId: string, folder: string): string => `x:${connectionId}${SEPARATOR}${folder}`;
+
 const appItemKey = (connectionId: string, folder: string, item: string): string => `${appFolderKey(connectionId, folder)}${SEPARATOR}${item}`;
+
 const entryKey = (ref: TableRef, part: TablePart, index: number): string => `${partKey(ref, part)}${SEPARATOR}${index}`;
 
 export const loadKey = (target: LoadTarget): string => {
     if (target.schema === undefined) {
         return connectionKey(target.connectionId);
     }
+
     return target.table === undefined
         ? schemaKey(target.connectionId, target.schema)
         : tableKey({ connectionId: target.connectionId, schema: target.schema, table: target.table });
@@ -142,7 +156,6 @@ export type TableEntry =
 
 export interface EntryRow extends RowBase {
     readonly kind: 'entry';
-    /* The table the entry belongs to. */
     readonly ref: TableRef;
     readonly entry: TableEntry;
 }
@@ -262,7 +275,6 @@ export interface TreeInput {
     folders?(connectionId: string): readonly ExplorerFolder[];
 }
 
-/* The schemas a list shows. */
 export const visibleSchemas = (schemas: readonly SchemaInfo[], showSystemSchemas: boolean): readonly SchemaInfo[] =>
     showSystemSchemas ? schemas : schemas.filter((schema) => !schema.system);
 
@@ -299,11 +311,14 @@ const matches = (name: string, query: string): boolean => name.toLowerCase().inc
 /* What each folder of a table besides its columns holds: the primary key and the unique keys, the foreign keys, the other indexes, the checks and the triggers. */
 export const tableEntries = (structure: TableStructure): Readonly<Record<Exclude<TablePart, 'columns'>, readonly TableEntry[]>> => {
     const primaryIndex = structure.indexes.find((index) => index.primary);
+
     const primary: TableEntry[] =
         structure.primaryKey.length === 0 ? [] : [{ type: 'key', name: primaryIndex?.name ?? null, columns: structure.primaryKey, primary: true }];
+
     const unique = structure.indexes
         .filter((index) => index.unique && !index.primary)
         .map((index): TableEntry => ({ type: 'key', name: index.name, columns: index.columns, primary: false }));
+
     return {
         keys: [...primary, ...unique],
         foreignKeys: structure.foreignKeys.map((foreignKey) => ({ type: 'foreignKey', foreignKey })),
@@ -324,6 +339,7 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
     const columnRows = (ref: TableRef, structure: TableStructure, level: number, parent: string): Draft[] => {
         const primary = new Set(structure.primaryKey);
         const foreign = new Set(structure.foreignKeys.flatMap((foreignKey) => foreignKey.columns));
+
         return structure.columns.map((column): Draft => ({
             make: (place) => ({
                 kind: 'column',
@@ -344,24 +360,33 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
     /* The folders a table opens into, each only when it holds something. A view has only its columns, straight under it. */
     const tableChildren = (ref: TableRef, kind: TableKind, level: number, parent: string): Draft[] => {
         const load = input.structures(ref.connectionId, ref.schema, ref.table);
+
         if (load.status !== 'ready') {
             return [pendingDraft(load, { connectionId: ref.connectionId, schema: ref.schema, table: ref.table }, level, parent)];
         }
+
         const structure = load.value;
+
         if (structure.columns.length === 0) {
             return [statusDraft({ kind: 'empty', of: 'columns' }, level, parent, true)];
         }
+
         if (kind === 'view') {
             return columnRows(ref, structure, level, parent);
         }
+
         const entries = tableEntries(structure);
+
         return PARTS.flatMap((part): Draft[] => {
             const count = part === 'columns' ? structure.columns.length : entries[part].length;
+
             if (count === 0) {
                 return [];
             }
+
             const key = partKey(ref, part);
             const open = startsOpen(key) ? !input.collapsed.has(key) : input.expanded.has(key);
+
             const below = (): Draft[] =>
                 part === 'columns'
                     ? columnRows(ref, structure, level + 1, key)
@@ -378,6 +403,7 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
                           }),
                           below: []
                       }));
+
             return [
                 {
                     make: (place) => ({ kind: 'part', key, level, parent, focusable: true, ref, part, expanded: open, count, ...place }),
@@ -390,6 +416,7 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
     const tableDraft = (ref: TableRef, table: TableInfo, level: number, parent: string): Draft => {
         const key = tableKey(ref);
         const open = input.expanded.has(key);
+
         return {
             make: (place) => ({ kind: 'table', key, level, parent, focusable: true, ref, table, expanded: open, ...place }),
             below: open ? settle(tableChildren(ref, table.kind, level + 1, key)) : []
@@ -399,19 +426,25 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
     /* The folders under a schema (or under a connection with only that schema), and how many tables they hold. */
     const folderDrafts = (connection: Connection, schema: string, level: number, parent: string): { drafts: Draft[]; tables: number } => {
         const load = input.tables(connection.id, schema);
+
         if (load.status === 'ready') {
             const shown = filtering ? load.value.filter((table) => matches(table.name, query)) : load.value;
+
             if (shown.length === 0 && !filtering) {
                 return { drafts: [statusDraft({ kind: 'empty', of: 'tables' }, level, parent, true)], tables: 0 };
             }
+
             const drafts = GROUPS.flatMap((group): Draft[] => {
                 const members = shown.filter((table) => table.kind === group);
+
                 if (members.length === 0) {
                     return [];
                 }
+
                 const key = folderKey(connection.id, schema, group);
                 const open = filtering || !input.collapsed.has(key);
                 const tables = members.map((table) => tableDraft({ connectionId: connection.id, schema, table: table.name }, table, level + 1, key));
+
                 return [
                     {
                         make: (place) => ({
@@ -431,21 +464,27 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
                     }
                 ];
             });
+
             return { drafts, tables: shown.length };
         }
+
         if (filtering) {
             return { drafts: [], tables: 0 };
         }
+
         return { drafts: [pendingDraft(load, { connectionId: connection.id, schema }, level, parent)], tables: 0 };
     };
 
     const schemaDraft = (connection: Connection, schema: string, parent: string): Draft | null => {
         const key = schemaKey(connection.id, schema);
         const { drafts, tables } = folderDrafts(connection, schema, 3, key);
+
         if (filtering && tables === 0) {
             return null;
         }
+
         const open = filtering || input.expanded.has(key);
+
         return {
             make: (place) => ({ kind: 'schema', key, level: 2, parent, focusable: true, connection, schema, expanded: open, ...place }),
             below: open ? settle(drafts) : []
@@ -456,11 +495,14 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
     const appFolderDrafts = (connection: Connection, level: number, parent: string): Draft[] =>
         (input.folders?.(connection.id) ?? []).flatMap((folder): Draft[] => {
             const items = filtering ? folder.items.filter((item) => matches(item.label, query)) : folder.items;
+
             if (items.length === 0) {
                 return [];
             }
+
             const key = appFolderKey(connection.id, folder.id);
             const open = filtering || input.expanded.has(key);
+
             const rows = items.map((item): Draft => ({
                 make: (place) => ({
                     kind: 'appItem',
@@ -474,6 +516,7 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
                 }),
                 below: []
             }));
+
             return [
                 {
                     make: (place) => ({
@@ -500,12 +543,15 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
         const open = filtering ? load.status === 'ready' || appFolders.length > 0 : input.expanded.has(key);
         let children: Draft[] = [];
         let schemaCount: ConnectionRow['schemaCount'] = null;
+
         if (load.status === 'ready') {
             const visible = visibleSchemas(load.value, input.showSystemSchemas);
             const sole = soleSchema(visible);
+
             if (visible.length < load.value.length) {
                 schemaCount = { shown: visible.length, total: load.value.length };
             }
+
             if (sole !== null) {
                 children = open ? folderDrafts(connection, sole, 2, key).drafts : [];
             } else if (visible.length === 0) {
@@ -516,12 +562,16 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
         } else if (open && !filtering) {
             children = [pendingDraft(load, { connectionId: connection.id }, 2, key)];
         }
+
         // Behind a status row too: what the app keeps of a connection does not wait on its server.
         children = [...children, ...(open ? appFolders : [])];
+
         if (filtering && children.length === 0) {
             return null;
         }
+
         const version = input.versions(connection.id);
+
         return {
             make: (place) => ({ kind: 'connection', key, level: 1, parent: null, focusable: true, connection, expanded: open, version, schemaCount, ...place }),
             below: open ? settle(children) : []
@@ -534,30 +584,41 @@ export const flattenTree = (input: TreeInput): TreeRow[] => {
 /* The loads an open node is waiting for and nobody has asked for yet. */
 export const neededLoads = (input: Omit<TreeInput, 'filter'>): LoadTarget[] => {
     const needed: LoadTarget[] = [];
+
     for (const connection of input.connections) {
         if (!input.expanded.has(connectionKey(connection.id))) {
             continue;
         }
+
         const load = input.schemas(connection.id);
+
         if (load.status === 'idle') {
             needed.push({ connectionId: connection.id });
+
             continue;
         }
+
         if (load.status !== 'ready') {
             continue;
         }
+
         const visible = visibleSchemas(load.value, input.showSystemSchemas);
         const sole = soleSchema(visible);
         const wanted = sole !== null ? [sole] : visible.map((schema) => schema.name).filter((name) => input.expanded.has(schemaKey(connection.id, name)));
+
         for (const schema of wanted) {
             const tables = input.tables(connection.id, schema);
+
             if (tables.status === 'idle') {
                 needed.push({ connectionId: connection.id, schema });
+
                 continue;
             }
+
             if (tables.status !== 'ready') {
                 continue;
             }
+
             for (const table of tables.value) {
                 if (
                     input.expanded.has(tableKey({ connectionId: connection.id, schema, table: table.name })) &&
@@ -568,6 +629,7 @@ export const neededLoads = (input: Omit<TreeInput, 'filter'>): LoadTarget[] => {
             }
         }
     }
+
     return needed;
 };
 
@@ -581,11 +643,14 @@ export type TreeAction =
 /* What a key does to the row that has the focus, or `null` when it does nothing there. */
 export const navigate = (rows: readonly TreeRow[], activeKey: string | null, pressed: string): TreeAction | null => {
     const stops = rows.filter((row) => row.focusable);
+
     if (stops.length === 0) {
         return null;
     }
+
     const at = stops.findIndex((row) => row.key === activeKey);
     const row = at === -1 ? null : stops[at]!;
+
     switch (pressed) {
         case 'ArrowDown':
             return { type: 'focus', key: stops[Math.min(at + 1, stops.length - 1)]!.key };
@@ -599,19 +664,24 @@ export const navigate = (rows: readonly TreeRow[], activeKey: string | null, pre
             if (row === null || !isExpandable(row)) {
                 return null;
             }
+
             if (!row.expanded) {
                 return { type: 'expand', key: row.key };
             }
+
             const child = stops.find((candidate) => candidate.parent === row.key);
+
             return child === undefined ? null : { type: 'focus', key: child.key };
         }
         case 'ArrowLeft': {
             if (row === null) {
                 return null;
             }
+
             if (isExpandable(row) && row.expanded) {
                 return { type: 'collapse', key: row.key };
             }
+
             return row.parent === null ? null : { type: 'focus', key: row.parent };
         }
         case 'Enter':
@@ -629,5 +699,6 @@ export const tabStop = (rows: readonly TreeRow[], activeKey: string | null, sele
             return key;
         }
     }
+
     return rows.find((row) => row.focusable)?.key ?? null;
 };