@adecore/database 0.38.0 → 0.40.0

package/src/connections/ConnectionManager.tsx

@@ -46,10 +46,12 @@ export function ConnectionManager({ value, onValueChange, selected, onSelectedCh
     const client = useDatabaseClient();
     const pickedId = selected === undefined ? own : selected;
     const current = value.find((connection) => connection.id === pickedId) ?? value[0] ?? null;
+
     // The answer of one connection is gone once another is picked, so coming back does not bring it back.
     if (outcome !== null && outcome.connectionId !== current?.id) {
         setOutcome(null);
     }
+
     // An answer to an older config is never shown for a newer one.
     const shown = outcome !== null && current !== null && outcome.config === current.config ? outcome : null;
 
@@ -57,6 +59,7 @@ export function ConnectionManager({ value, onValueChange, selected, onSelectedCh
         if (selected === undefined) {
             setOwn(id);
         }
+
         onSelectedChange?.(id);
     };
 
@@ -192,6 +195,7 @@ export function ConnectionManager({ value, onValueChange, selected, onSelectedCh
 function DockerMenuItems({ onPick }: { onPick(container: DockerContainer): void }) {
     const { t } = useTranslation('database');
     const { state, reload } = useDockerContainers();
+
     if (state.status === 'loading') {
         return (
             <Menu.Label className="flex items-center gap-2">
@@ -200,6 +204,7 @@ function DockerMenuItems({ onPick }: { onPick(container: DockerContainer): void
             </Menu.Label>
         );
     }
+
     if (state.status !== 'ready') {
         return (
             <>
@@ -212,10 +217,13 @@ function DockerMenuItems({ onPick }: { onPick(container: DockerContainer): void
             </>
         );
     }
+
     const containers = state.containers.filter(isMysqlContainer);
+
     if (containers.length === 0) {
         return <Menu.Label>{t('connections.fromDocker.empty')}</Menu.Label>;
     }
+
     return containers.map((container) => (
         <Menu.Item key={container.id} onClick={() => onPick(container)}>
             <span className="flex min-w-0 flex-col">
@@ -235,6 +243,7 @@ function ConnectionTest({ connection, onOutcome }: { connection: Connection; onO
     const test = async (): Promise<void> => {
         const config = connection.config;
         setBusy(true);
+
         try {
             onOutcome({ connectionId: connection.id, config, info: await client.test(config) });
         } catch (e) {

package/src/connections/connection-config.ts

@@ -34,9 +34,11 @@ export const isAbsolutePath = (path: string): boolean => /^(?:\/|[A-Za-z]:[\\/]|
 
 const sqliteProblems = (config: SqliteConnectionConfig): ConfigProblems => {
     const path = config.path.trim();
+
     if (path === '') {
         return { path: 'path-required' };
     }
+
     return isAbsolutePath(path) ? {} : { path: 'path-relative' };
 };
 
@@ -47,6 +49,7 @@ export const modeOf = (config: MysqlConnectionConfig): ConnectMode => {
     if (config.tunnel !== undefined) {
         return config.tunnel.kind;
     }
+
     return config.socket === undefined ? 'tcp' : 'socket';
 };
 
@@ -54,31 +57,39 @@ const mysqlProblems = (config: MysqlConnectionConfig): ConfigProblems => {
     const problems: { -readonly [K in keyof ConfigProblems]: ConfigProblems[K] } = {};
     const tunnel = config.tunnel;
     const mode = modeOf(config);
+
     if (mode === 'socket' && (config.socket ?? '').trim() === '') {
         problems.socket = 'socket-required';
     }
+
     if ((mode === 'tcp' || mode === 'ssh') && config.host.trim() === '') {
         problems.host = 'host-required';
     }
+
     if ((mode === 'tcp' || mode === 'ssh') && config.port !== undefined && !isPort(config.port)) {
         problems.port = 'port-range';
     }
+
     if (tunnel?.kind === 'ssh') {
         if (tunnel.host.trim() === '') {
             problems.sshHost = 'ssh-host-required';
         }
+
         if (tunnel.port !== undefined && !isPort(tunnel.port)) {
             problems.sshPort = 'ssh-port-range';
         }
     }
+
     if (tunnel?.kind === 'docker') {
         if (tunnel.container.trim() === '') {
             problems.container = 'container-required';
         }
+
         if (tunnel.port !== undefined && !isPort(tunnel.port)) {
             problems.containerPort = 'container-port-range';
         }
     }
+
     return problems;
 };
 
@@ -90,30 +101,38 @@ export const isValidConfig = (config: ConnectionConfig): boolean => Object.keys(
 
 const lastSegment = (path: string): string => {
     const segments = path.split(/[\\/]/).filter((segment) => segment !== '');
+
     return segments[segments.length - 1] ?? path;
 };
 
 const targetWhere = (config: MysqlConnectionConfig): string => {
     const tunnel = config.tunnel;
+
     if (tunnel?.kind === 'docker') {
         return tunnel.container === '' ? 'Docker' : `${tunnel.container} (Docker)`;
     }
+
     if (tunnel?.kind === 'ssh') {
         return tunnel.host === '' ? config.host : `${config.host} via ${tunnel.host}`;
     }
+
     if (config.socket !== undefined) {
         return lastSegment(config.socket);
     }
+
     return `${config.host}:${config.port ?? DEFAULT_MYSQL_PORT}`;
 };
 
 /* The short line under a connection's name: the file name of a database file, or `user@host:port`, `user@host via <ssh host>` and `user@container (Docker)`. */
 export const targetOf = (connection: Connection): string => {
     const config = connection.config;
+
     if (config.engine === 'sqlite') {
         return lastSegment(config.path);
     }
+
     const where = targetWhere(config);
+
     return config.user === '' || where === '' ? where : `${config.user}@${where}`;
 };
 
@@ -122,12 +141,14 @@ export const withMode = (config: MysqlConnectionConfig, mode: ConnectMode): Mysq
     if (modeOf(config) === mode) {
         return config;
     }
+
     const base: MysqlConnectionConfig = {
         ...config,
         host: config.host.trim() === '' ? DEFAULT_HOST : config.host,
         socket: undefined,
         tunnel: undefined
     };
+
     switch (mode) {
         case 'tcp':
             return base;

package/src/connections/docker.ts

@@ -15,6 +15,7 @@ export const containerTitle = (container: DockerContainer): string => composeNam
 /* The port to connect to inside the container: MySQL's own when the container lists it or lists nothing, else the first it lists. */
 export const containerPortOf = (container: DockerContainer): number => {
     const ports = container.ports.map((entry) => entry.container);
+
     return ports.length === 0 || ports.includes(DEFAULT_MYSQL_PORT) ? DEFAULT_MYSQL_PORT : ports[0]!;
 };
 
@@ -28,6 +29,7 @@ const isEmpty = (text: string | undefined): boolean => text === undefined || tex
 export const withContainer = (config: MysqlConnectionConfig, container: DockerContainer): MysqlConnectionConfig => {
     const docker = withMode(config, 'docker');
     const { user, password, database } = container.suggested;
+
     return {
         ...docker,
         user: isEmpty(docker.user) && user !== undefined ? user : docker.user,

package/src/connections/use-docker-containers.ts

@@ -19,16 +19,19 @@ export function useDockerContainers(): { readonly state: DockerState; reload():
 
     useEffect(() => {
         const controller = new AbortController();
+
         client.discover('docker', { signal: controller.signal }).then(
             (containers) => setState({ status: 'ready', containers }),
             (e: unknown) => {
                 if (controller.signal.aborted) {
                     return;
                 }
+
                 const message = messageOf(e);
                 setState({ status: e instanceof DatabaseRequestError && e.code === 'unsupported' ? 'unsupported' : 'error', message });
             }
         );
+
         return () => controller.abort();
     }, [client, attempt]);
 

package/src/console/DestructiveDialog.tsx

@@ -15,6 +15,7 @@ export interface DestructiveDialogProps {
 /* Lists the statements that cannot be taken back and asks before they run. */
 export function DestructiveDialog({ statements, onConfirm, onCancel, ref }: DestructiveDialogProps) {
     const { t } = useTranslation('database');
+
     return (
         <PromptDialog
             ref={ref}

package/src/console/QueryConsole.tsx

@@ -9,6 +9,7 @@ import type { DatabaseNotice } from '../actions.ts';
 import { useDatabaseAction, useDatabaseClient, useDatabaseFiles, useDatabaseNotice, useDatabaseStorage } from '../client-context.ts';
 import type { FileFormat, RowsResult, SchemaInfo, StatementResult } from '../protocol/index.ts';
 import { splitStatements, statementAt } from '../sql-split.ts';
+import { parseStoredSize } from '../stored-size.ts';
 import { DestructiveDialog } from './DestructiveDialog.tsx';
 import type { QueryConsoleEditorHandle, QueryConsoleEditorProps, QueryConsoleRunScope } from './editor-slot.ts';
 import { findDestructive, type DestructiveStatement } from './destructive.ts';
@@ -72,15 +73,6 @@ export const RESULTS_HEIGHT_KEY = 'database:console-results';
 const MIN_RESULTS_HEIGHT = 96;
 const MIN_EDITOR_HEIGHT = 120;
 
-const parseHeight = (raw: string | null | undefined): number | null => {
-    try {
-        const value: unknown = JSON.parse(raw ?? 'null');
-        return typeof value === 'number' && Number.isFinite(value) && value >= MIN_RESULTS_HEIGHT ? Math.round(value) : null;
-    } catch {
-        return null;
-    }
-};
-
 /* The app's editor as an element of its own, so it gets its props the way `SqlEditor` does and not during the console's render. */
 function AppEditor({ render, ...editor }: QueryConsoleEditorProps & { render(editor: QueryConsoleEditorProps): ReactNode }) {
     return render(editor);
@@ -154,12 +146,14 @@ export function QueryConsole({
     const channel = `console:${useId()}`;
     const session = useMemo(() => (connection === undefined ? null : client.session(connection, channel)), [client, connection, channel]);
     const engine = connection?.config.engine;
+
     useEffect(
         () => () => {
             void session?.close();
         },
         [session]
     );
+
     // Nothing is recorded without a connection, so the key of none is never written.
     const history = useConsoleHistory(connection?.id ?? '');
     const running = useRef<AbortController | null>(null);
@@ -186,7 +180,8 @@ export function QueryConsole({
     const [notice, setNotice] = useState<DatabaseNotice | null>(null);
     // Closed until the first run, so the editor has the whole height before anything ran.
     const [resultsOpen, setResultsOpen] = useState(false);
-    const [resultsHeight, setResultsHeight] = useState(() => parseHeight(storage?.get(RESULTS_HEIGHT_KEY)));
+    const [resultsHeight, setResultsHeight] = useState(() => parseStoredSize(storage?.get(RESULTS_HEIGHT_KEY), MIN_RESULTS_HEIGHT));
+
     const { startResize } = useColumnResize(resultsPane, {
         size: resultsHeight ?? MIN_RESULTS_HEIGHT,
         min: MIN_RESULTS_HEIGHT,
@@ -194,6 +189,7 @@ export function QueryConsole({
         max: () => (resultsPane.current?.parentElement?.clientHeight ?? 0) - MIN_EDITOR_HEIGHT,
         onSize: setResultsHeight
     });
+
     const sql = value ?? own;
     const blank = sql.trim() === '';
     const busy = run.status === 'running' || settling;
@@ -216,11 +212,14 @@ export function QueryConsole({
         if (session === null || engine !== 'mysql') {
             return undefined;
         }
+
         const controller = new AbortController();
+
         session
             .schemas({ signal: controller.signal })
             .then((list) => setSchemas(orderSchemas(list)))
             .catch(() => undefined);
+
         return () => controller.abort();
     }, [engine, session]);
 
@@ -236,6 +235,7 @@ export function QueryConsole({
         if (value === undefined) {
             setOwn(next);
         }
+
         onValueChange?.(next);
     };
 
@@ -244,15 +244,20 @@ export function QueryConsole({
         if (engine === undefined) {
             return null;
         }
+
         const selection = editorHandle.current?.selection();
+
         if (scope === 'all' || selection === undefined) {
             return splitStatements(sql, engine).length === 0 ? null : sql;
         }
+
         const { start, end } = selection;
         const selected = sql.slice(start, end);
+
         if (splitStatements(selected, engine).length > 0) {
             return selected;
         }
+
         return statementAt(sql, start, engine)?.text ?? null;
     };
 
@@ -260,11 +265,15 @@ export function QueryConsole({
         if (target === null || busy || engine === undefined) {
             return;
         }
+
         const statements = findDestructive(target, engine);
+
         if (statements.length > 0) {
             setConfirming({ target, statements });
+
             return;
         }
+
         void execute(target);
     };
 
@@ -272,18 +281,22 @@ export function QueryConsole({
         if (session === null || connection === undefined) {
             return;
         }
+
         const controller = new AbortController();
         const mine = ++generation.current;
         running.current = controller;
         setResultsOpen(true);
         setRun({ status: 'running' });
         setNotice(null);
+
         const record = (outcome: Pick<HistoryEntry, 'ok' | 'rows'>): void =>
             history.record({ sql: target, at: Date.now(), connection: connection.name, ...outcome });
+
         try {
             if (mode === 'manual' && !inTransaction) {
                 setInTransaction(await session.transaction('begin', { signal: controller.signal }));
             }
+
             // A cancel that stopped the run midway still answers what ran and whether a transaction stayed open.
             const executed = await session.execute(target, { schema: activeSchema, limit: PAGE_SIZE, signal: controller.signal });
             setInTransaction(executed.inTransaction);
@@ -307,6 +320,7 @@ export function QueryConsole({
 
     const pickHistory = (entry: HistoryEntry, runIt: boolean): void => {
         changeSql(entry.sql);
+
         if (runIt) {
             requestRun(entry.sql);
         }
@@ -316,9 +330,12 @@ export function QueryConsole({
         if (session === null) {
             return false;
         }
+
         setSettling(true);
+
         try {
             setInTransaction(await session.transaction(action));
+
             return true;
         } catch (error) {
             notify({
@@ -326,6 +343,7 @@ export function QueryConsole({
                 title: t(action === 'commit' ? 'console.transaction.commitFailed' : 'console.transaction.rollbackFailed'),
                 description: messageOf(error)
             });
+
             return false;
         } finally {
             setSettling(false);
@@ -336,6 +354,7 @@ export function QueryConsole({
         if (await settle(action)) {
             setMode('auto');
         }
+
         setEndingManual(false);
     };
 
@@ -351,11 +370,14 @@ export function QueryConsole({
         if (session === null) {
             return;
         }
+
         const mine = generation.current;
         setPaging(true);
         setNotice(null);
+
         try {
             const rows = await session.page(result.sql, { schema: activeSchema, offset, limit: PAGE_SIZE });
+
             if (generation.current === mine) {
                 setPages((current) => ({ ...current, [index]: { offset, rows, before } }));
             }
@@ -370,9 +392,12 @@ export function QueryConsole({
         if (files === undefined || session === null) {
             return;
         }
+
         setExporting(true);
+
         try {
             const path = await files.save({ suggestedName: `result.${format}`, format });
+
             if (path !== null) {
                 const exported = await session.export({ source: { kind: 'query', sql: result.sql, schema: activeSchema }, format, path });
                 notify({ tone: 'success', title: t('console.exported', { count: exported.rows, formatted: formatNumber(exported.rows) }) });
@@ -391,6 +416,7 @@ export function QueryConsole({
     const shown: StatementResult | undefined = base?.kind === 'rows' && page !== undefined ? { kind: 'rows', sql: base.sql, ...page.rows } : base;
     const offset = page?.offset ?? 0;
     const before = page?.before ?? [];
+
     const pager: ResultPager | undefined =
         base?.kind === 'rows' && shown?.kind === 'rows' && engine !== undefined && isPageable(base.sql, engine) && (shown.hasMore || offset > 0)
             ? {
@@ -400,6 +426,7 @@ export function QueryConsole({
                   onNext: () => void loadPage(index, base, offset + shown.rows.length, [...before, offset])
               }
             : undefined;
+
     const exportBase = files !== undefined && base?.kind === 'rows' ? base : undefined;
     // Read for the statement, not for each page of it, so paging through a result asks for nothing again.
     const keys = useResultKeys(session, engine, base);
@@ -538,6 +565,7 @@ export function QueryConsole({
                 onConfirm={() => {
                     const target = confirming?.target;
                     setConfirming(null);
+
                     if (target !== undefined) {
                         void execute(target);
                     }

package/src/console/SchemaPicker.tsx

@@ -13,9 +13,9 @@ export interface SchemaPickerProps {
     ref?: Ref<HTMLButtonElement>;
 }
 
-/* Picks the schema the console's statements run in. */
 export function SchemaPicker({ schemas, value, onValueChange, disabled, className, ref }: SchemaPickerProps) {
     const { t } = useTranslation('database');
+
     return (
         <Select
             ref={ref}

package/src/console/SqlEditor.tsx

@@ -26,6 +26,7 @@ export function SqlEditor({ ref, value, onValueChange, run, label, placeholder,
 
     useEffect(() => {
         const pending = pendingSelection.current;
+
         if (pending !== null) {
             pendingSelection.current = null;
             pending.area.setSelectionRange(pending.start, pending.end);
@@ -37,29 +38,38 @@ export function SqlEditor({ ref, value, onValueChange, run, label, placeholder,
         const before = target.value;
         target.setSelectionRange(edit.from, edit.to);
         const inserted = document.execCommand('insertText', false, edit.insert);
+
         if (inserted && target.value === applyEdit(before, edit)) {
             target.setSelectionRange(edit.selectionStart, edit.selectionEnd);
+
             return;
         }
+
         pendingSelection.current = { area: target, start: edit.selectionStart, end: edit.selectionEnd };
         onValueChange(applyEdit(before, edit));
     };
 
     const handleKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>): void => {
         const scope = runScopeOf(event, isApplePlatform());
+
         if (scope !== null) {
             event.preventDefault();
             run(scope);
+
             return;
         }
+
         if (event.nativeEvent.isComposing || event.metaKey || event.ctrlKey || event.altKey) {
             return;
         }
+
         const target = event.currentTarget;
         const { selectionStart, selectionEnd } = target;
+
         if (event.key === 'Tab') {
             event.preventDefault();
             const edit = event.shiftKey ? outdentEdit(target.value, selectionStart, selectionEnd) : indentEdit(target.value, selectionStart, selectionEnd);
+
             if (edit !== null) {
                 apply(target, edit);
             }

package/src/console/StatementResultView.tsx

@@ -4,6 +4,7 @@ import { useTranslation } from 'react-i18next';
 import { Banner, ButtonGroup, ContextMenu, Icon, IconButton, Menu, Spinner } from '@adecore/ui';
 import { formatDecimal, formatNumber } from '@adecore/ui/format';
 import type { DatabaseNotice } from '../actions.ts';
+import { EXPORT_FORMATS } from '../export-formats.ts';
 import { DataGrid } from '../grid/DataGrid.tsx';
 import { previewValueOf } from '../grid/focused-value.ts';
 import type { FocusedCell, GridMenuContext, GridRow } from '../grid/types.ts';
@@ -17,8 +18,6 @@ import { ValuePanel } from '../value/ValuePanel.tsx';
 /* What "Copy as SQL INSERT" names the table of a result that comes from no table. */
 const RESULT_TABLE = 'result';
 
-const EXPORT_FORMATS: readonly FileFormat[] = ['csv', 'tsv', 'json', 'sql'];
-
 /* Paging through the rows of a statement that reads, one page at a time. */
 export interface ResultPager {
     /* Counted from 1. */
@@ -66,10 +65,12 @@ export function StatementResultView({
 }: StatementResultViewProps) {
     const { t } = useTranslation('database');
     const [focus, setFocus] = useState<FocusedCell | null>(null);
+
     const rows = useMemo(
         () => (result.kind === 'rows' ? result.rows.map((cells, index): GridRow => ({ key: `row:${index}`, number: offset + index + 1, cells })) : []),
         [result, offset]
     );
+
     const sqlTarget = useMemo((): SqlTarget | undefined => (engine === undefined ? undefined : { engine, table: RESULT_TABLE }), [engine]);
     const elapsed = t('console.elapsed', { value: formatDecimal(result.elapsedMs) });
 
@@ -115,17 +116,21 @@ export function StatementResultView({
 
     const referenceAt = (cell: FocusedCell): Reference | null => {
         const row = rows.find((candidate) => candidate.key === cell.rowKey);
+
         return keys === null || row === undefined ? null : keys.referenceAt(cell.column, row.cells);
     };
+
     const follow =
         keys === null || onFollowReference === undefined
             ? undefined
             : (cell: FocusedCell): void => {
                   const reference = referenceAt(cell);
+
                   if (reference !== null) {
                       onFollowReference(reference);
                   }
               };
+
     const referenceMenu = (context: GridMenuContext): ReactNode =>
         follow === undefined || context.cell === null || keys?.isReference(context.cell.column) !== true ? null : (
             <ContextMenu.Item disabled={referenceAt(context.cell) === null} onClick={() => context.cell !== null && follow(context.cell)}>

package/src/console/TransactionControls.tsx

@@ -21,6 +21,7 @@ export interface TransactionControlsProps {
 /* Auto-commit on or off, and while a transaction is open, the way to end it. */
 export function TransactionControls({ mode, onModeChange, open, busy, onCommit, onRollback, className, ref }: TransactionControlsProps) {
     const { t } = useTranslation('database');
+
     return (
         <div ref={ref} className={clsx('flex items-center gap-2', className)}>
             <Tooltip label={t('console.transaction.hint')}>

package/src/console/destructive.ts

@@ -18,8 +18,10 @@ interface Word {
 const wordsOf = (sql: string, engine: Engine): Word[] => {
     const words: Word[] = [];
     let depth = 0;
+
     for (const token of tokenize(sql, engine)) {
         const text = sql.slice(token.start, token.end);
+
         if (token.kind === 'word') {
             words.push({ word: text.toUpperCase(), depth });
         } else if (token.kind === 'punct' && text === '(') {
@@ -28,27 +30,35 @@ const wordsOf = (sql: string, engine: Engine): Word[] => {
             depth = Math.max(0, depth - 1);
         }
     }
+
     return words;
 };
 
 const kindOf = (sql: string, engine: Engine): DestructiveKind | null => {
     const words = wordsOf(sql, engine);
     const first = words[0]?.word;
+
     if (first === 'DROP') {
         return 'drop';
     }
+
     if (first === 'TRUNCATE') {
         return 'truncate';
     }
+
     if (first === 'ALTER') {
         return words.some(({ word }) => word === 'DROP') ? 'alterDrop' : null;
     }
+
     // A statement behind a `WITH` is the first DELETE or UPDATE outside any parentheses.
     const writer = first === 'WITH' ? words.find(({ word, depth }) => depth === 0 && (word === 'DELETE' || word === 'UPDATE')) : words[0];
+
     if (writer?.word !== 'DELETE' && writer?.word !== 'UPDATE') {
         return null;
     }
+
     const filtered = words.some(({ word, depth }) => word === 'WHERE' && depth === 0);
+
     return filtered ? null : writer.word === 'DELETE' ? 'delete' : 'update';
 };
 
@@ -56,5 +66,6 @@ const kindOf = (sql: string, engine: Engine): DestructiveKind | null => {
 export const findDestructive = (sql: string, engine: Engine): DestructiveStatement[] =>
     splitStatements(sql, engine).flatMap((statement) => {
         const kind = kindOf(statement.text, engine);
+
         return kind === null ? [] : [{ sql: statement.text, kind }];
     });

package/src/console/editing.ts

@@ -15,6 +15,7 @@ const lineStartOf = (value: string, at: number): number => value.lastIndexOf('\n
 
 const lineEndOf = (value: string, at: number): number => {
     const newline = value.indexOf('\n', at);
+
     return newline === -1 ? value.length : newline;
 };
 
@@ -24,6 +25,7 @@ const indentOf = (line: string): string => /^[ \t]*/.exec(line)![0];
 const touchedLines = (value: string, start: number, end: number): { from: number; to: number } => {
     const from = lineStartOf(value, start);
     const last = end > start && value[end - 1] === '\n' ? end - 1 : end;
+
     return { from, to: lineEndOf(value, last) };
 };
 
@@ -32,8 +34,10 @@ export const indentEdit = (value: string, start: number, end: number): TextEdit
     if (!value.slice(start, end).includes('\n')) {
         return { from: start, to: end, insert: INDENT, selectionStart: start + INDENT.length, selectionEnd: start + INDENT.length };
     }
+
     const { from, to } = touchedLines(value, start, end);
     const lines = value.slice(from, to).split('\n');
+
     return {
         from,
         to,
@@ -47,16 +51,21 @@ export const indentEdit = (value: string, start: number, end: number): TextEdit
 export const outdentEdit = (value: string, start: number, end: number): TextEdit | null => {
     const { from, to } = touchedLines(value, start, end);
     const lines = value.slice(from, to).split('\n');
+
     const removed = lines.map((line) => {
         if (line.startsWith('\t')) {
             return 1;
         }
+
         return Math.min(INDENT.length, /^ */.exec(line)![0].length);
     });
+
     const total = removed.reduce((sum, count) => sum + count, 0);
+
     if (total === 0) {
         return null;
     }
+
     return {
         from,
         to,
@@ -71,5 +80,6 @@ export const newlineEdit = (value: string, start: number, end: number): TextEdit
     const lineStart = lineStartOf(value, start);
     const indent = indentOf(value.slice(lineStart, start));
     const insert = `\n${indent}`;
+
     return { from: start, to: end, insert, selectionStart: start + insert.length, selectionEnd: start + insert.length };
 };