@adecore/database 0.39.0 → 0.40.1

package/src/table/pending.ts

@@ -30,9 +30,11 @@ export const valuesEqual = (left: EditValue | undefined, right: EditValue | unde
     if (left === undefined || right === undefined) {
         return false;
     }
+
     if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object') {
         return left === right;
     }
+
     return left.kind === right.kind && (left.kind !== 'binary' || (right.kind === 'binary' && left.hex === right.hex));
 };
 
@@ -41,6 +43,7 @@ export const setEdit = (pending: PendingChanges, row: number, column: string, va
     const { [row]: current = {}, ...others } = pending.edits;
     const { [column]: _replaced, ...kept } = current;
     const next = valuesEqual(value, valueOfCell(original)) ? kept : { ...kept, [column]: value };
+
     return { ...pending, edits: Object.keys(next).length === 0 ? others : { ...others, [row]: next } };
 };
 
@@ -69,6 +72,7 @@ export const revertRow = (pending: PendingChanges, row: number): PendingChanges
     const { [row]: _dropped, ...edits } = pending.edits;
     const deletes = new Set(pending.deletes);
     deletes.delete(row);
+
     return { ...pending, edits, deletes };
 };
 
@@ -81,6 +85,7 @@ export interface RowSelectionRefs {
 /* Takes back every change to the given rows: the edits and deletion marks of the loaded ones, and the inserted ones altogether. */
 export const revertRows = (pending: PendingChanges, rows: RowSelectionRefs): PendingChanges => {
     const reverted = rows.loaded.reduce(revertRow, pending);
+
     return { ...reverted, inserts: reverted.inserts.filter((row) => !rows.inserted.includes(row.id)) };
 };
 
@@ -97,18 +102,24 @@ type LoadedRows = Pick<RowsResult, 'columns' | 'rows'>;
  */
 export const rowKeyOf = (structure: TableStructure, loaded: LoadedRows, row: number): RowKey | null => {
     const cells = loaded.rows[row];
+
     if (structure.rowKey === null || cells === undefined) {
         return null;
     }
+
     const key: Record<string, Value> = {};
+
     for (const name of structure.rowKey) {
         const index = loaded.columns.findIndex((column) => column.name === name);
         const value = index < 0 ? undefined : valueOfCell(cells[index] as Cell);
+
         if (value === undefined) {
             return null;
         }
+
         key[name] = value;
     }
+
     return key;
 };
 
@@ -116,18 +127,23 @@ export const rowKeyOf = (structure: TableStructure, loaded: LoadedRows, row: num
 export const toRowChanges = (structure: TableStructure, loaded: LoadedRows, pending: PendingChanges): RowChange[] => {
     const keyOf = (row: number): RowKey => {
         const key = rowKeyOf(structure, loaded, row);
+
         if (key === null) {
             throw new Error(`Row ${row + 1} of ${structure.name} has no usable key.`);
         }
+
         return key;
     };
+
     const updates = Object.keys(pending.edits)
         .map(Number)
         .filter((row) => !pending.deletes.has(row))
         .sort((left, right) => left - right)
         .map((row): RowChange => ({ kind: 'update', key: keyOf(row), values: pending.edits[row]! }));
+
     const deletes = [...pending.deletes].sort((left, right) => left - right).map((row): RowChange => ({ kind: 'delete', key: keyOf(row) }));
     const inserts = pending.inserts.map((row): RowChange => ({ kind: 'insert', values: row.values }));
+
     return [...updates, ...deletes, ...inserts];
 };
 
@@ -135,9 +151,11 @@ const keyValueText = (value: Value): string => {
     if (value === null) {
         return 'NULL';
     }
+
     if (typeof value === 'object') {
         return `0x${value.hex}`;
     }
+
     return typeof value === 'string' ? `'${value}'` : String(value);
 };
 

package/src/table/references.ts

@@ -25,14 +25,18 @@ export const referenceOf = (
     cells: readonly Shown[]
 ): Reference | null => {
     const matches: ColumnMatch[] = [];
+
     for (const [position, name] of key.columns.entries()) {
         const referenced = key.referencedColumns[position];
         const index = columns.findIndex((column) => column.name === name);
         const value = index < 0 ? undefined : wholeValueOf(cells[index] ?? null);
+
         if (referenced === undefined || value === undefined || value === null) {
             return null;
         }
+
         matches.push({ column: referenced, value, kind: columns[index]!.kind });
     }
+
     return matches.length === 0 ? null : { schema: key.referencedSchema, table: key.referencedTable, where: matchCondition(engine, matches) };
 };

package/src/table/useLoaded.ts

@@ -33,6 +33,7 @@ export function useLoaded<T>(load: (signal: AbortSignal) => Promise<T>, key: str
 
     useEffect(() => {
         const controller = new AbortController();
+
         loader.current(controller.signal).then(
             (value) => {
                 if (!controller.signal.aborted) {
@@ -45,10 +46,12 @@ export function useLoaded<T>(load: (signal: AbortSignal) => Promise<T>, key: str
                 }
             }
         );
+
         return () => controller.abort();
     }, [key, version]);
 
     const answered = state.key === key && state.version === version;
+
     return {
         value: state.value,
         loading: !answered,

package/src/table/useStoredLayout.ts

@@ -30,6 +30,7 @@ export function useStoredLayout(storage: DatabaseStorage | undefined, key: strin
     const write = useCallback((): void => {
         clearTimeout(timer.current);
         timer.current = undefined;
+
         if (dirty.current) {
             dirty.current = false;
             target.current.storage?.set(target.current.key, serializeLayout(latest.current));
@@ -44,6 +45,7 @@ export function useStoredLayout(storage: DatabaseStorage | undefined, key: strin
             if (storage === undefined) {
                 return;
             }
+
             latest.current = { ...latest.current, ...change };
             dirty.current = true;
             clearTimeout(timer.current);

package/src/table/useTableTransfer.ts

@@ -49,7 +49,6 @@ export interface TableTransfer {
     readonly notice: TransferNotice | null;
     readonly importDraft: ImportDraft | null;
     exportAs(format: FileFormat): void;
-    /* Stops the export that is running. */
     cancelExport(): void;
     dismiss(): void;
     chooseImportFile(): void;
@@ -71,7 +70,9 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (notice?.kind !== 'exported' && notice?.kind !== 'imported') {
             return;
         }
+
         const timer = setTimeout(() => setNotice(null), NOTICE_MS);
+
         return () => clearTimeout(timer);
     }, [notice]);
 
@@ -90,19 +91,24 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (files === undefined || exporting.current !== null) {
             return;
         }
+
         void (async () => {
             const path = await files.save({ suggestedName: `${table}.${format}`, format });
+
             if (path === null) {
                 return;
             }
+
             const controller = new AbortController();
             exporting.current = controller;
             setNotice({ kind: 'exporting', format });
+
             try {
                 const result = await session.export(
                     { source: { kind: 'table', schema, table, where: where || undefined, orderBy: orderBy || undefined }, format, path },
                     { signal: controller.signal }
                 );
+
                 show({ kind: 'exported', rows: result.rows });
             } catch (error) {
                 if (controller.signal.aborted || isCancelled(error)) {
@@ -120,6 +126,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         sampling.current?.abort();
         const controller = new AbortController();
         sampling.current = controller;
+
         return await client.sample(path, format, header, { signal: controller.signal });
     };
 
@@ -127,12 +134,16 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (files === undefined || structure === null) {
             return;
         }
+
         void (async () => {
             const path = await files.open({ formats: ['csv', 'tsv'] });
+
             if (path === null) {
                 return;
             }
+
             const format = formatOfPath(path);
+
             try {
                 const read = await sample(path, format, true);
                 setImportDraft({ path, format, header: true, sample: read, mapping: matchColumns(read.columns, tableColumns, true), busy: false, error: null });
@@ -146,11 +157,14 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (importDraft === null) {
             return;
         }
+
         const { path, format } = importDraft;
         setImportDraft({ ...importDraft, header, sample: null, error: null });
+
         void (async () => {
             try {
                 const read = await sample(path, format, header);
+
                 setImportDraft((now) =>
                     now === null || now.path !== path ? now : { ...now, header, sample: read, mapping: matchColumns(read.columns, tableColumns, header) }
                 );
@@ -170,8 +184,10 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (importDraft === null || importDraft.busy || importDraft.sample === null) {
             return;
         }
+
         const { path, format, header, mapping } = importDraft;
         setImportDraft({ ...importDraft, busy: true, error: null });
+
         void (async () => {
             try {
                 const rows = await session.import(schema, table, { path, format, header, columns: mapping });

package/src/testing/fake.ts

@@ -149,6 +149,7 @@ const rowKeyOf = (table: Table): string[] | null => {
     const unique = table.indexes.find(
         (index) => index.unique && index.columns.every((name) => table.columns.find((column) => column.name === name)?.nullable === false)
     );
+
     return unique === undefined ? null : [...unique.columns];
 };
 
@@ -180,6 +181,7 @@ const toCell = (value: Value, cellLimit: number): Cell => {
 
     if (value !== null && typeof value === 'object') {
         const length = value.hex.length / 2;
+
         return { kind: 'binary', hex: value.hex.slice(0, Math.min(length, cellLimit) * 2), length };
     }
 
@@ -196,16 +198,20 @@ interface ByteBudget {
 
 const toRowsResult = (table: Table, rows: readonly (readonly Value[])[], offset: number, limit: number, cellLimit: number, budget: ByteBudget): RowsResult => {
     const page: Cell[][] = [];
+
     for (const row of rows.slice(offset, offset + limit)) {
         const cells = row.map((value) => toCell(value, cellLimit));
         // Characters rather than bytes: near enough for a fake.
         const size = JSON.stringify(cells).length;
+
         if (page.length > 0 && size > budget.left) {
             return { columns: toResultColumns(table), rows: page, hasMore: true, elapsedMs: 0 };
         }
+
         budget.left = Math.max(0, budget.left - size);
         page.push(cells);
     }
+
     return { columns: toResultColumns(table), rows: page, hasMore: rows.length > offset + limit, elapsedMs: 0 };
 };
 
@@ -213,6 +219,7 @@ const toRowsResult = (table: Table, rows: readonly (readonly Value[])[], offset:
 const defaultOf = (column: ColumnInfo, table: Table): Value => {
     if (column.autoIncrement) {
         const index = table.columns.indexOf(column);
+
         return table.rows.reduce((highest, row) => (typeof row[index] === 'number' ? Math.max(highest, row[index]) : highest), 0) + 1;
     }
 
@@ -272,6 +279,7 @@ const applyChanges = (table: Table, changes: DatabaseParams<'apply'>['changes'])
 
             const row = table.columns.map((column) => {
                 const given = Object.hasOwn(change.values, column.name) ? change.values[column.name]! : { kind: 'default' as const };
+
                 return resolveEdit(column, draft, given);
             });
 
@@ -285,6 +293,7 @@ const applyChanges = (table: Table, changes: DatabaseParams<'apply'>['changes'])
             }
 
             draft.rows.push(row);
+
             return;
         }
 
@@ -302,6 +311,7 @@ const applyChanges = (table: Table, changes: DatabaseParams<'apply'>['changes'])
 
         if (change.kind === 'delete') {
             draft.rows.splice(draft.rows.indexOf(row), 1);
+
             return;
         }
 
@@ -312,6 +322,7 @@ const applyChanges = (table: Table, changes: DatabaseParams<'apply'>['changes'])
     });
 
     table.rows = draft.rows;
+
     return changes.length;
 };
 
@@ -331,6 +342,7 @@ const selectedTable = (session: Session, sql: string): Table => {
 const runStatement = (session: Session, sql: string, limit: number, cellLimit: number, budget: ByteBudget): StatementResult => {
     try {
         const table = selectedTable(session, sql);
+
         return { kind: 'rows', sql, ...toRowsResult(table, table.rows, 0, limit, cellLimit, budget) };
     } catch (error) {
         if (error instanceof FakeError) {
@@ -402,15 +414,18 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
             const session = connect(connection);
             const id = `fake-${++counter}`;
             sessions.set(id, session);
+
             return { session: id, server: serverOf(connection) };
         },
         close: ({ session }) => {
             sessionOf(session);
             sessions.delete(session);
+
             return null;
         },
         test: ({ connection }) => {
             connect(connection);
+
             return { server: serverOf(connection) };
         },
         schemas: ({ session }) => ({
@@ -418,10 +433,12 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
         }),
         tables: ({ session, schema }) => {
             const tables = findSchema(sessionOf(session), schema);
+
             return { tables: [...tables].map(([name, table]) => ({ name, kind: table.kind, rowEstimate: table.rows.length, comment: null })) };
         },
         structure: ({ session, schema, table: name }) => {
             const table = findTable(sessionOf(session), schema, name);
+
             return {
                 schema,
                 name,
@@ -438,6 +455,7 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
         },
         rows: ({ session, schema, table: name, offset, limit, cellLimit, maxBytes }) => {
             const table = findTable(sessionOf(session), schema, name);
+
             return toRowsResult(table, table.rows, offset, limit, cellLimit ?? DEFAULT_ROWS_CELL_LIMIT, { left: maxBytes ?? DEFAULT_MAX_BYTES });
         },
         count: ({ session, schema, table: name }) => ({ count: findTable(sessionOf(session), schema, name).rows.length }),
@@ -491,15 +509,18 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
             const target = sessionOf(session);
             selectSchema(target, schema);
             const table = selectedTable(target, sql);
+
             return toRowsResult(table, table.rows, offset, limit, cellLimit ?? DEFAULT_EXECUTE_CELL_LIMIT, { left: maxBytes ?? DEFAULT_MAX_BYTES });
         },
         transaction: ({ session, action }) => {
             const target = sessionOf(session);
             target.inTransaction = action === 'begin';
+
             return { active: target.inTransaction };
         },
         export: ({ session }) => {
             sessionOf(session);
+
             throw new FakeError('unsupported', 'The fake database has no files to export to.');
         },
         sample: () => {
@@ -507,12 +528,14 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
         },
         import: ({ session }) => {
             sessionOf(session);
+
             throw new FakeError('unsupported', 'The fake database has no files to import from.');
         },
         discover: () => ({ containers: structuredClone([...(options.containers ?? [])]) }),
         cancel: ({ request }) => {
             const stop = waiting.get(request);
             stop?.();
+
             return { cancelled: stop !== undefined };
         }
     };
@@ -520,6 +543,7 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
     const answer = (request: DatabaseRequest): DatabaseResponse => {
         try {
             const handler = handlers[request.method] as (params: unknown) => unknown;
+
             return { id: request.id, ok: true, result: handler(request.params) } as DatabaseResponse;
         } catch (error) {
             if (error instanceof FakeError) {

package/src/use-database-resources.ts

@@ -7,6 +7,7 @@ import { addDatabaseResources } from './locales.ts';
 export function useDatabaseResources(): void {
     const { i18n } = useTranslation();
     const [added, setAdded] = useState<I18n | null>(null);
+
     if (added !== i18n) {
         addDatabaseResources(i18n);
         setAdded(i18n);

package/src/use-popup-press.ts

@@ -13,7 +13,9 @@ export function usePopupPress(): () => boolean {
         const press = (e: PointerEvent): void => {
             pressed.current = isInFloatingLayer(e.target);
         };
+
         document.addEventListener('pointerdown', press, true);
+
         return () => {
             document.removeEventListener('pointerdown', press, true);
         };
@@ -22,6 +24,7 @@ export function usePopupPress(): () => boolean {
     return () => {
         const was = pressed.current;
         pressed.current = false;
+
         return was;
     };
 }

package/src/value/ValueEditor.tsx

@@ -75,7 +75,9 @@ export function ValueEditor({ column, value, editable, onCommit }: ValueEditorPr
         if (!editable || onCommit === undefined || !dirty) {
             return;
         }
+
         const conversion = editValueOf(draft, source);
+
         if (conversion.ok) {
             onCommit(conversion.value);
         } else {
@@ -123,9 +125,11 @@ export function ValueEditor({ column, value, editable, onCommit }: ValueEditorPr
         if (content.kind === 'empty') {
             return <Faint>{placeholder}</Faint>;
         }
+
         if (content.kind === 'problem') {
             return <Faint>{problemText(content.problem)}</Faint>;
         }
+
         return (
             <>
                 <pre className={clsx(READING, wrapped ? 'break-words whitespace-pre-wrap' : 'whitespace-pre')}>{content.text}</pre>
@@ -142,6 +146,7 @@ export function ValueEditor({ column, value, editable, onCommit }: ValueEditorPr
         if (view === 'text') {
             return editor('min-h-0 flex-1');
         }
+
         if (view === 'hex' && editable) {
             return (
                 <>
@@ -150,6 +155,7 @@ export function ValueEditor({ column, value, editable, onCommit }: ValueEditorPr
                 </>
             );
         }
+
         return rendered === null ? null : reading(rendered, wrap && WRAPPING_VIEWS.has(view));
     };
 

package/src/value/draft.ts

@@ -30,6 +30,7 @@ const textOf = (value: Exclude<Value, null>): string => (typeof value === 'objec
 export const sourceOf = (column: Pick<GridColumn, 'name' | 'type' | 'kind'>, value: Value): Source => {
     const binary = column.kind === 'binary' || (value !== null && typeof value === 'object');
     const original: Draft = value === null ? { text: '', mode: 'null' } : { text: textOf(value), mode: 'value' };
+
     return {
         name: column.name,
         type: column.type,
@@ -50,18 +51,24 @@ export const editValueOf = (draft: Draft, source: Source): Conversion => {
     if (draft.mode === 'null') {
         return { ok: true, value: null };
     }
+
     if (draft.mode === 'default') {
         return { ok: true, value: { kind: 'default' } };
     }
+
     if (source.binary) {
         const parsed = parseHex(draft.text);
+
         return parsed.ok ? { ok: true, value: { kind: 'binary', hex: parsed.hex } } : { ok: false, problem: { kind: 'hex', problem: parsed.problem } };
     }
+
     if (source.json) {
         const checked = checkJson(draft.text);
+
         if (!checked.ok) {
             return { ok: false, problem: { kind: 'json', reason: checked.reason } };
         }
     }
+
     return { ok: true, value: parseDraft(draft.text, source.kind) };
 };

package/src/value/hex.ts

@@ -15,17 +15,21 @@ const UUID_BYTES = 16;
 export const parseHex = (text: string): ParsedHex => {
     const stripped = text.replace(/\s+/g, '').toLowerCase();
     const hex = stripped.startsWith('0x') ? stripped.slice(2) : stripped;
+
     if (NOT_HEX.test(hex)) {
         return { ok: false, problem: 'characters' };
     }
+
     return hex.length % 2 === 0 ? { ok: true, hex } : { ok: false, problem: 'odd' };
 };
 
 export const bytesOf = (hex: string): Uint8Array => {
     const bytes = new Uint8Array(hex.length / 2);
+
     for (let i = 0; i < bytes.length; i++) {
         bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
     }
+
     return bytes;
 };
 
@@ -37,6 +41,7 @@ export const formatUuid = (hex: string): string | null => {
     if (hex.length !== UUID_BYTES * 2) {
         return null;
     }
+
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 };
 
@@ -51,12 +56,15 @@ const slotsOf = (bytes: Uint8Array, from: number, to: number): string =>
 export const hexDumpLines = (hex: string, maxBytes = Number.POSITIVE_INFINITY): string[] => {
     const bytes = bytesOf(hex.slice(0, Math.min(hex.length, maxBytes * 2)));
     const lines: string[] = [];
+
     for (let offset = 0; offset < bytes.length; offset += BYTES_PER_LINE) {
         const line = bytes.subarray(offset, offset + BYTES_PER_LINE);
         const ascii = Array.from(line, (byte) => (isPrintable(byte) ? String.fromCharCode(byte) : '.')).join('');
+
         lines.push(
             `${offset.toString(16).padStart(8, '0')}  ${slotsOf(bytes, offset, offset + GROUP)}  ${slotsOf(bytes, offset + GROUP, offset + BYTES_PER_LINE)}  |${ascii}|`
         );
     }
+
     return lines;
 };

package/src/value/json.ts

@@ -7,6 +7,7 @@ export type JsonCheck = { readonly ok: true } | { readonly ok: false; readonly r
 export const checkJson = (text: string): JsonCheck => {
     try {
         JSON.parse(text);
+
         return { ok: true };
     } catch (error) {
         return { ok: false, reason: error instanceof Error ? error.message : String(error) };
@@ -16,6 +17,7 @@ export const checkJson = (text: string): JsonCheck => {
 /* Whether a string is a JSON object or array. A scalar such as `42` or `"x"` is a plain value, not a document. */
 export const isJsonDocument = (text: string): boolean => {
     const start = text.trimStart()[0];
+
     return (start === '{' || start === '[') && checkJson(text).ok;
 };
 
@@ -28,34 +30,46 @@ export const prettyJson = (text: string): string | null => {
     let output = '';
     let depth = 0;
     let i = 0;
+
     const lineBreak = () => `\n${INDENT.repeat(depth)}`;
+
     const nextToken = (from: number): string => {
         let at = from;
+
         while (/\s/.test(text[at] ?? '')) {
             at++;
         }
+
         return text[at] ?? '';
     };
 
     while (i < text.length) {
         const char = text[i]!;
+
         if (char === '"') {
             let end = i + 1;
+
             while (text[end] !== '"') {
                 end += text[end] === '\\' ? 2 : 1;
             }
+
             output += text.slice(i, end + 1);
             i = end + 1;
+
             continue;
         }
+
         if (char === '{' || char === '[') {
             const close = char === '{' ? '}' : ']';
             output += char;
+
             if (nextToken(i + 1) === close) {
                 output += close;
                 i = text.indexOf(close, i + 1) + 1;
+
                 continue;
             }
+
             depth++;
             output += lineBreak();
         } else if (char === '}' || char === ']') {
@@ -68,7 +82,9 @@ export const prettyJson = (text: string): string | null => {
         } else if (!/\s/.test(char)) {
             output += char;
         }
+
         i++;
     }
+
     return output.trim();
 };

package/src/value/views.ts

@@ -9,8 +9,10 @@ export const viewsOf = (source: Source, draft: Draft): ViewId[] => {
     if (source.binary) {
         const parsed = parseHex(draft.text);
         const hex = parsed.ok ? parsed.hex : source.original.text;
+
         return formatUuid(hex) === null ? ['hex', 'utf8'] : ['hex', 'utf8', 'uuid'];
     }
+
     return source.json ? ['formatted', 'text'] : ['text'];
 };
 
@@ -19,10 +21,13 @@ export const sizeOf = (source: Source, draft: Draft): { unit: 'bytes' | 'charact
     if (draft.mode !== 'value') {
         return null;
     }
+
     if (!source.binary) {
         return { unit: 'characters', count: draft.text.length };
     }
+
     const parsed = parseHex(draft.text);
+
     return parsed.ok ? { unit: 'bytes', count: parsed.hex.length / 2 } : null;
 };
 
@@ -40,26 +45,35 @@ export const renderView = (view: Exclude<ViewId, 'text'>, draft: Draft): Rendere
     if (draft.mode !== 'value') {
         return { kind: 'empty' };
     }
+
     if (view === 'formatted') {
         const pretty = prettyJson(draft.text);
+
         if (pretty !== null) {
             return { kind: 'text', text: pretty };
         }
+
         const checked = checkJson(draft.text);
+
         return { kind: 'problem', problem: { kind: 'json', reason: checked.ok ? '' : checked.reason } };
     }
 
     const parsed = parseHex(draft.text);
+
     if (!parsed.ok) {
         return { kind: 'problem', problem: { kind: 'hex', problem: parsed.problem } };
     }
+
     if (view === 'utf8') {
         return { kind: 'text', text: decodeUtf8(parsed.hex) };
     }
+
     if (view === 'uuid') {
         return { kind: 'text', text: formatUuid(parsed.hex) ?? '' };
     }
+
     const total = parsed.hex.length / 2;
+
     return {
         kind: 'text',
         text: hexDumpLines(parsed.hex, DUMP_LIMIT_BYTES).join('\n'),