@adecore/editor 0.41.1 → 0.42.0

package/dist/view.js

@@ -5,6 +5,7 @@ import { createSearchClient } from './search-client.js';
 import { FindController } from './find.js';
 import { EditorLayout, RIGHT_PADDING, subRowBand } from './layout.js';
 import { createMetrics, readEditorFont } from './metrics.js';
+import { zoomedFont } from './zoom.js';
 import { AttributionRuns, colorValue, tintValue } from './attribution.js';
 import { renderCodeBlock } from './code-block.js';
 import { emit, subscribe } from './listeners.js';
@@ -16,6 +17,7 @@ import { Outline, scopeChain, stickyCover, stickyPlacements, structuralEntries }
 import { overviewTicks, paintOverview } from './overview.js';
 import { paintCarets, paintGutter, paintOver, paintOverlays, paintRemoteCarets, paintSigns, paintSticky, RowPainter } from './paint.js';
 import { overlayTokens } from './semantic.js';
+import { TodoMarks } from './todos.js';
 import { TokenCache } from './tokens.js';
 function sameRect(left, right) {
     return left.left === right.left && left.top === right.top && left.right === right.right && left.bottom === right.bottom;
@@ -79,6 +81,7 @@ export class EditorView {
     layout;
     find;
     tokens;
+    todos;
     content;
     gutter;
     gutterLines;
@@ -147,6 +150,8 @@ export class EditorView {
     caretTimer;
     caretKey = '';
     renderedScroll = { top: -1, left: -1 };
+    /* A size the code is zoomed to, over the page's; null draws it at the page's. */
+    fontSize = null;
     font;
     layoutVersion = 0;
     revision;
@@ -281,6 +286,7 @@ export class EditorView {
             }
         });
         this.tokens = new TokenCache({ getLineCount: () => model.getLineCount(), getLineText: (line) => model.getLine(line).text });
+        this.todos = new TodoMarks(model, () => this.requestRender());
         const ResizeObserverClass = document.defaultView?.ResizeObserver;
         this.blockObserver = ResizeObserverClass
             ? new ResizeObserverClass((entries) => {
@@ -311,6 +317,7 @@ export class EditorView {
         this.root.dataset.readonly = String(this.settings.readOnly);
         this.root.dataset.wrap = String(this.settings.wrap);
         this.root.dataset.foldOutline = this.settings.foldOutline;
+        this.todos.configure(this.settings.language, this.settings.todoWords);
         this.layoutVersion++;
         this.layout.configure({ metrics: createMetrics(this.font, this.settings.tabSize, this.document) });
         this.render();
@@ -320,8 +327,26 @@ export class EditorView {
         this.render();
     }
     refreshFont() {
-        this.font = readEditorFont(this.root);
-        this.applySettings();
+        const style = this.root.style;
+        style.removeProperty('--code-font-size');
+        style.removeProperty('--code-line-height');
+        const base = readEditorFont(this.root);
+        this.font = this.fontSize === null ? base : zoomedFont(base, this.fontSize);
+        // On the element itself, so everything the editor draws at the code's size follows, and the page's size stays the base.
+        if (this.fontSize !== null) {
+            style.setProperty('--code-font-size', `${this.font.size}px`);
+            style.setProperty('--code-line-height', `${this.font.lineHeight}px`);
+        }
+        this.anchorScroll(() => this.applySettings());
+    }
+    /* Draws the code at a size of its own in whole pixels; null goes back to the page's. */
+    setFontSize(size) {
+        this.fontSize = size;
+        this.refreshFont();
+    }
+    /* The size the code is drawn at, in pixels. */
+    getFontSize() {
+        return this.font.size;
     }
     setTokenizer(tokenizer) {
         this.tokens.setTokenizer(tokenizer);
@@ -421,8 +446,12 @@ export class EditorView {
         this.semanticLines.clear();
         this.render();
     }
-    /* The grammar's colors of a line with the servers' laid over them, the same object for as long as neither changed. */
+    /* The colors of a line with its TODOs drawn over them, the same object for as long as nothing under them changed. */
     styledTokensOf(line) {
+        return this.todos.styled(line, this.semanticTokensOf(line));
+    }
+    /* The grammar's colors of a line with the servers' laid over them, the same object for as long as neither changed. */
+    semanticTokensOf(line) {
         const base = this.lineTokenProvider === null ? this.tokens.tokensOf(line) : (this.lineTokenProvider(line) ?? null);
         if (base === null || this.semantic.length === 0 || this.scopeColors === null) {
             return base;
@@ -615,6 +644,7 @@ export class EditorView {
             this.find.refresh();
             this.announceFind();
             this.scheduleFolds();
+            this.todos.schedule();
             this.colorAhead(true);
         }
         if (this.rowEndCaret !== null && this.model.getPrimary().head !== this.rowEndCaret) {
@@ -2228,7 +2258,7 @@ export class EditorView {
         const matches = this.find.matches;
         const current = this.find.current;
         const alike = this.selectionOccurrences();
-        const key = `${this.revision}|${this.changeVersion}|${this.markerVersion}|${this.layout.height}|${trackHeight}|${matches.length}|${current}|${matches[0]?.from}|${matches.at(-1)?.from}|${this.selectionOccurrenceCache.key}`;
+        const key = `${this.revision}|${this.changeVersion}|${this.markerVersion}|${this.todos.version}|${this.layout.height}|${trackHeight}|${matches.length}|${current}|${matches[0]?.from}|${matches.at(-1)?.from}|${this.selectionOccurrenceCache.key}`;
         if (key === this.overviewKey) {
             return;
         }
@@ -2255,6 +2285,11 @@ export class EditorView {
                 });
             }
         }
+        for (const todo of this.todos.marks) {
+            if (todo.line < this.model.getLineCount()) {
+                spans.push({ kind: 'todo', top: rowTop(todo.line), bottom: rowBottom(todo.line), offset: todo.from, title: todo.text });
+            }
+        }
         for (const range of alike) {
             const line = this.model.positionAt(range.from).line;
             spans.push({ kind: 'occurrence', top: rowTop(line), bottom: rowBottom(line) });
@@ -2427,6 +2462,7 @@ export class EditorView {
         this.blockObserver?.disconnect();
         clearTimeout(this.bracketTimer);
         clearTimeout(this.foldTimer);
+        this.todos.dispose();
         clearTimeout(this.colorTimer);
         clearTimeout(this.noticeTimer);
         clearTimeout(this.liveTimer);

package/dist/zoom.d.ts

@@ -0,0 +1,18 @@
+import type { EditorFont } from './metrics.ts';
+import type { EditorZoom } from './types.ts';
+export declare const MIN_FONT_SIZE = 12;
+export declare const MAX_FONT_SIZE = 90;
+export interface FontSizeRange {
+    readonly min: number;
+    readonly max: number;
+}
+export declare function fontSizeRange(zoom: EditorZoom | undefined): FontSizeRange;
+export declare function clampFontSize(size: number, range: FontSizeRange): number;
+export declare function zoomedFont(base: EditorFont, size: number): EditorFont;
+export declare class WheelZoom {
+    private pending;
+    step(event: {
+        deltaY: number;
+        deltaMode: number;
+    }): number;
+}

package/dist/zoom.js

@@ -0,0 +1,41 @@
+/* Nothing a person reads is smaller. */
+export const MIN_FONT_SIZE = 12;
+export const MAX_FONT_SIZE = 90;
+/* A trackpad or a pinch sends the wheel in small steps; this many pixels of them are one step of the size. */
+const PIXELS_PER_STEP = 20;
+export function fontSizeRange(zoom) {
+    const min = Math.max(MIN_FONT_SIZE, Math.round(zoom?.min ?? MIN_FONT_SIZE));
+    return { min, max: Math.max(min, Math.round(zoom?.max ?? MAX_FONT_SIZE)) };
+}
+/* In whole pixels inside the range. */
+export function clampFontSize(size, range) {
+    return Math.min(range.max, Math.max(range.min, Math.round(size)));
+}
+/* The face at another size, with the line as much taller as the page's line is to its text, in whole pixels. */
+export function zoomedFont(base, size) {
+    return { family: base.family, size, lineHeight: Math.round((size * base.lineHeight) / base.size) };
+}
+/* Turns the wheel with the zoom modifier, or a pinch, into steps of one pixel: up and apart make the text larger. */
+export class WheelZoom {
+    pending = 0;
+    /* -1, 0 or 1. A mouse notch is one step however far the platform says it went. */
+    step(event) {
+        if (event.deltaY === 0) {
+            return 0;
+        }
+        if (event.deltaMode !== 0 || Math.abs(event.deltaY) >= PIXELS_PER_STEP) {
+            this.pending = 0;
+            return event.deltaY < 0 ? 1 : -1;
+        }
+        if (Math.sign(this.pending) !== 0 && Math.sign(this.pending) !== Math.sign(event.deltaY)) {
+            this.pending = 0;
+        }
+        this.pending += event.deltaY;
+        if (Math.abs(this.pending) < PIXELS_PER_STEP) {
+            return 0;
+        }
+        const direction = this.pending < 0 ? 1 : -1;
+        this.pending = 0;
+        return direction;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor",
-  "version": "0.41.1",
+  "version": "0.42.0",
   "type": "module",
   "exports": {
     ".": {
@@ -54,7 +54,7 @@
     "test": "bun test --conditions=source"
   },
   "dependencies": {
-    "@adecore/editor-core": "0.41.1",
+    "@adecore/editor-core": "0.42.0",
     "linkedom": "^0.18.14",
     "shiki": "^4.5.0"
   },

package/src/controller.ts

@@ -8,6 +8,7 @@ import { NativeInput } from './native-input.ts';
 import { columnSelections, sameCell } from './column-selection.ts';
 import { PointerSelection } from './pointer.ts';
 import { TouchSelection } from './touch.ts';
+import { WheelZoom } from './zoom.ts';
 import type {
     EditorClick,
     EditorClickHandler,
@@ -29,6 +30,10 @@ export interface ControllerOptions {
     apple: boolean;
     save(): void;
     blur(): void;
+    /* One pixel larger (1) or smaller (-1), or back to the page's size (0). */
+    zoom(step: -1 | 0 | 1): void;
+    /* Whether the zoom modifier with the wheel, or a pinch, zooms. */
+    wheelZooms(): boolean;
 }
 
 const MODIFYING = new Set<EditorCommand>([
@@ -53,7 +58,12 @@ const MODIFYING = new Set<EditorCommand>([
     'outdent',
     'insertNewline',
     'smartBackspace',
-    'deleteForward'
+    'deleteForward',
+    'sortLines',
+    'reverseLines',
+    'uniqueLines',
+    'convertIndentsToSpaces',
+    'convertIndentsToTabs'
 ]);
 
 const VIEW_COMMANDS = new Set<EditorViewCommand>([
@@ -71,9 +81,14 @@ const VIEW_COMMANDS = new Set<EditorViewCommand>([
     'expandAllToLevel3',
     'expandAllToLevel4',
     'expandAllToLevel5',
-    'toggleColumnMode'
+    'toggleColumnMode',
+    'increaseFontSize',
+    'decreaseFontSize',
+    'resetFontSize'
 ]);
 
+const ZOOM_STEPS = { increaseFontSize: 1, decreaseFontSize: -1, resetFontSize: 0 } as const satisfies Partial<Record<EditorViewCommand, -1 | 0 | 1>>;
+
 /* The clipboard text of the last copy or cut of a bare caret, which pastes back as whole lines. Shared, since it can be pasted in another editor. */
 let lineClip: string | null = null;
 
@@ -109,6 +124,7 @@ export class InputController {
     /* The Extend Selection presses that wait for a server's ranges, which are answered one after the other. */
     private expansions: Promise<void> = Promise.resolve();
     private lastInputAt = 0;
+    private readonly wheelZoom = new WheelZoom();
     private desiredXs: number[] = [];
     private keepDesiredXs = false;
     private readonly view: EditorView;
@@ -230,7 +246,7 @@ export class InputController {
         this.listen(input, 'copy', (event) => this.copy(event, false));
         this.listen(input, 'cut', (event) => this.copy(event, true));
         this.listen(viewport, 'scroll', () => this.view.scrolled());
-        this.listen(viewport, 'wheel', () => this.view.cancelScroll());
+        this.listen(viewport, 'wheel', (event) => this.wheel(event));
         this.listen(viewport, 'pointermove', (event) => this.view.hoverMoved(event));
 
         this.listen(viewport, 'pointerleave', () => {
@@ -378,11 +394,17 @@ export class InputController {
     private viewCommand(name: EditorViewCommand): boolean {
         const { view } = this;
 
+        if (name in ZOOM_STEPS) {
+            this.options.zoom(ZOOM_STEPS[name as keyof typeof ZOOM_STEPS]);
+
+            return true;
+        }
+
         if (view.settings.folding === false && name !== 'toggleColumnMode') {
             return false;
         }
 
-        const run: Record<EditorViewCommand, () => void> = {
+        const run: Record<Exclude<EditorViewCommand, keyof typeof ZOOM_STEPS>, () => void> = {
             collapseRegion: () => view.collapseRegion(),
             expandRegion: () => view.expandRegion(),
             collapseAllRegions: () => view.foldAll(true),
@@ -400,11 +422,27 @@ export class InputController {
             toggleColumnMode: () => this.toggleColumnMode()
         };
 
-        run[name]();
+        run[name as keyof typeof run]();
 
         return true;
     }
 
+    /* A pinch comes as the wheel with Ctrl, on every platform. */
+    private wheel(event: WheelEvent): void {
+        this.view.cancelScroll();
+
+        if (!(event.ctrlKey || (this.options.apple && event.metaKey)) || !this.options.wheelZooms()) {
+            return;
+        }
+
+        event.preventDefault();
+        const step = this.wheelZoom.step(event);
+
+        if (step !== 0) {
+            this.options.zoom(step as -1 | 1);
+        }
+    }
+
     /* Runs a model command on every caret, with the folds that would hide its result opened first. */
     command(name: EditorRunCommand): boolean {
         if (VIEW_COMMANDS.has(name as EditorViewCommand)) {

package/src/editor.css

@@ -17,6 +17,7 @@
     --editor-added: var(--status-idle);
     --editor-modified: var(--accent);
     --editor-deleted: var(--status-error);
+    --editor-todo: var(--status-running);
     --editor-mark-number-mix: 72%;
     --editor-mark-bar-width: 3px;
     --editor-mark-gap: 4px;
@@ -38,6 +39,7 @@
     --editor-margin: color-mix(in srgb, var(--text) 16%, transparent);
     --editor-whitespace: color-mix(in srgb, var(--text) 32%, transparent);
     --editor-hatch: color-mix(in srgb, var(--text) 10%, transparent);
+    --editor-todo: var(--status-idle);
     --editor-mark-number-mix: 82%;
     --editor-sticky-shadow: color-mix(in srgb, black 60%, transparent);
 }
@@ -478,11 +480,15 @@
     left: 6px;
     background: var(--editor-occurrence);
 }
+.se-tick-todo,
 .se-tick-error,
 .se-tick-warning,
 .se-tick-info {
     left: 10px;
 }
+.se-tick-todo {
+    background: var(--editor-todo);
+}
 /* The only part of the track that takes the pointer, with a wider reach than the 4px it draws. */
 .se-tick[data-offset] {
     pointer-events: auto;

package/src/engine.ts

@@ -53,11 +53,13 @@ import type {
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
+    EditorWhitespaceCleanup,
     EditorWidget,
     SmartEditorEngineOptions
 } from './types.ts';
 import { fillLens, lensSignature } from './lens.ts';
 import { EditorView, type ViewSettings } from './view.ts';
+import { clampFontSize, type FontSizeRange, fontSizeRange } from './zoom.ts';
 
 const DEFAULT_TAB_SIZE = 4;
 const DEFAULT_LABEL = 'Code editor';
@@ -77,6 +79,9 @@ class SmartEditor implements Editor {
     private caretOffset = 0;
     private readonly saves = new Set<Listener>();
     private readonly blurs = new Set<Listener>();
+    private readonly fontSizes = new Set<(size: number | null) => void>();
+    private readonly fontSizeRange: FontSizeRange;
+    private fontSize: number | null = null;
     private readonly subscription: { dispose(): void };
     private language: string | undefined;
     private theme: EditorTheme;
@@ -91,6 +96,7 @@ class SmartEditor implements Editor {
 
     constructor(engine: SmartEditorEngineOptions, element: HTMLElement, options: EditorOptions) {
         this.engine = engine;
+        this.fontSizeRange = fontSizeRange(options.zoom);
         this.model = new DocumentModel(options.text);
         this.language = options.language;
         this.theme = options.theme;
@@ -111,7 +117,8 @@ class SmartEditor implements Editor {
             whitespace: options.whitespace === true,
             rightMargin: options.rightMargin ?? null,
             foldOutline: options.foldOutline ?? 'hover',
-            folding: options.folding !== false
+            folding: options.folding !== false,
+            todoWords: options.todoWords
         };
 
         this.view = new EditorView(element, this.model, this.settings);
@@ -122,9 +129,15 @@ class SmartEditor implements Editor {
             keymap: engine.keymap,
             apple: engine.apple ?? false,
             save: () => emit(this.saves),
-            blur: () => emit(this.blurs)
+            blur: () => emit(this.blurs),
+            zoom: (step) => this.zoom(step),
+            wheelZooms: () => options.zoom?.wheel !== false
         });
 
+        if (options.fontSize !== undefined) {
+            this.setFontSize(options.fontSize);
+        }
+
         this.revision = this.model.getRevision();
         this.caretOffset = this.model.getPrimary().head;
 
@@ -392,6 +405,17 @@ class SmartEditor implements Editor {
         }
     }
 
+    cleanUpWhitespace(options: EditorWhitespaceCleanup): boolean {
+        const changed = !this.settings.readOnly && this.model.cleanUpWhitespace({ ...options, language: this.settings.language });
+        this.model.markSaved();
+
+        return changed;
+    }
+
+    markSaved(): void {
+        this.model.markSaved();
+    }
+
     setMarkers(markers: readonly EditorMarker[]): void {
         this.view.setMarkers(
             markers.map((marker) => ({
@@ -905,6 +929,11 @@ class SmartEditor implements Editor {
         this.view.applySettings();
     }
 
+    setTodoWords(words: readonly string[]): void {
+        this.settings.todoWords = [...words];
+        this.view.applySettings();
+    }
+
     setFoldHints(hints: EditorFoldHints | null): void {
         this.view.setFoldHints(hints === null ? null : this.foldHintsByOffset(hints));
     }
@@ -960,6 +989,40 @@ class SmartEditor implements Editor {
         this.view.refreshFont();
     }
 
+    setFontSize(size: number | null): void {
+        const next = size === null || !Number.isFinite(size) ? null : clampFontSize(size, this.fontSizeRange);
+
+        if (next !== this.fontSize) {
+            this.fontSize = next;
+            this.view.setFontSize(next);
+        }
+    }
+
+    getFontSize(): number {
+        return this.view.getFontSize();
+    }
+
+    onFontSizeChange(listener: (size: number | null) => void): () => void {
+        return subscribe(this.fontSizes, listener);
+    }
+
+    /* Steps from the size on screen, so the first step from the page's size is one pixel away from it. */
+    private zoom(step: -1 | 0 | 1): void {
+        const before = this.fontSize;
+        const current = this.view.getFontSize();
+
+        // A page size outside the range must not make a step the other way.
+        if (step !== 0 && Math.sign(clampFontSize(current + step, this.fontSizeRange) - current) !== step) {
+            return;
+        }
+
+        this.setFontSize(step === 0 ? null : current + step);
+
+        if (this.fontSize !== before) {
+            emit(this.fontSizes, this.fontSize);
+        }
+    }
+
     setReadOnly(readOnly: boolean, reason?: string): void {
         this.settings.readOnly = readOnly;
         this.settings.readOnlyReason = reason;
@@ -994,6 +1057,7 @@ class SmartEditor implements Editor {
         this.carets.clear();
         this.saves.clear();
         this.blurs.clear();
+        this.fontSizes.clear();
         this.subscription.dispose();
         this.controller.dispose();
         this.view.dispose();

package/src/fake.ts

@@ -49,6 +49,7 @@ import type {
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
+    EditorWhitespaceCleanup,
     EditorWidget
 } from './types.ts';
 import { emit, type Listener, subscribe } from './listeners.ts';
@@ -254,6 +255,8 @@ export class FakeEditor implements Editor {
         this.readOnly = options.readOnly ?? false;
         this.readOnlyReason = options.readOnlyReason;
         this.label = options.label ?? 'Code editor';
+        this.todoWords = options.todoWords;
+        this.fontSize = options.fontSize ?? null;
         this.revealedLine = options.line ?? null;
         this.column = options.column ?? null;
         this.scrollTop = options.scrollTop ?? null;
@@ -810,6 +813,12 @@ export class FakeEditor implements Editor {
         this.label = label;
     }
 
+    todoWords: readonly string[] | undefined;
+
+    setTodoWords(words: readonly string[]): void {
+        this.todoWords = [...words];
+    }
+
     setFoldHints(hints: EditorFoldHints | null): void {
         this.foldHints = hints;
     }
@@ -1126,6 +1135,22 @@ export class FakeEditor implements Editor {
         return this.edit(ordered, 'command', options.mergeUndo === true, place);
     }
 
+    /* The options of every cleanup asked for, in order; the fake changes no text for them. */
+    readonly cleanups: EditorWhitespaceCleanup[] = [];
+    /* How often the text was marked as saved, by a cleanup or on its own. */
+    savedMarks = 0;
+
+    cleanUpWhitespace(options: EditorWhitespaceCleanup): boolean {
+        this.cleanups.push({ ...options });
+        this.markSaved();
+
+        return false;
+    }
+
+    markSaved(): void {
+        this.savedMarks += 1;
+    }
+
     setTheme(theme: EditorTheme): void {
         this.theme = theme;
     }
@@ -1134,6 +1159,28 @@ export class FakeEditor implements Editor {
         this.fontRefreshes += 1;
     }
 
+    /* The size `setFontSize` set, null for the page's. */
+    fontSize: number | null = null;
+    private readonly fontSizeListeners = new Set<(size: number | null) => void>();
+
+    setFontSize(size: number | null): void {
+        this.fontSize = size;
+    }
+
+    getFontSize(): number {
+        return this.fontSize ?? 13;
+    }
+
+    onFontSizeChange(listener: (size: number | null) => void): () => void {
+        return subscribe(this.fontSizeListeners, listener);
+    }
+
+    /* What a person zooming would do: the new size goes to the listeners. */
+    zoomTo(size: number | null): void {
+        this.fontSize = size;
+        emit(this.fontSizeListeners, size);
+    }
+
     setReadOnly(readOnly: boolean, reason?: string): void {
         this.readOnly = readOnly;
         this.readOnlyReason = reason;

package/src/index.ts

@@ -1,6 +1,8 @@
 export { MAX_REPLACEMENT_PAGE, MAX_REPLACEMENT_CHARACTERS } from './search-protocol.ts';
 export { AGENT_COLORS } from './attribution.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from '@adecore/editor-core';
+export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from '@adecore/editor-core';
+export { detectIndentation, type DetectedIndentation } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.ts';
 export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
 export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
@@ -65,7 +67,9 @@ export type {
     EditorSelectionRanges,
     EditorTheme,
     EditorViewCommand,
+    EditorWhitespaceCleanup,
     EditorWidget,
+    EditorZoom,
     FoldRole,
     KeyChord,
     LineToken,

package/src/keymap-table.ts

@@ -41,6 +41,12 @@ export const KEYMAP = {
     splitLine: bind('Mod+Enter'),
     toggleCase: bind('Mod+Shift+U'),
     autoIndentLines: bind('Ctrl+Alt+I'),
+    // The platform binds no chord to these, so they live in the menu and the palette.
+    sortLines: bind(null),
+    reverseLines: bind(null),
+    uniqueLines: bind(null),
+    convertIndentsToSpaces: bind(null),
+    convertIndentsToTabs: bind(null),
 
     expandSelection: bind('Alt+ArrowUp', 'Ctrl+W'),
     shrinkSelection: bind('Alt+ArrowDown'),
@@ -85,6 +91,10 @@ export const KEYMAP = {
     expandAllToLevel3: bind(null),
     expandAllToLevel4: bind(null),
     expandAllToLevel5: bind(null),
+    // The platform binds no chord to these, and the zoom chords of other editors are the fold keys here.
+    increaseFontSize: bind(null),
+    decreaseFontSize: bind(null),
+    resetFontSize: bind(null),
 
     triggerCompletion: bind('Ctrl+Space'),
     parameterInfo: bind('Mod+P'),
@@ -123,7 +133,16 @@ export const KEYMAP = {
 export type KeymapId = keyof typeof KEYMAP;
 
 /* Commands added after a host may have written a full keymap of its own; a keymap without one falls back to the built-in chord. */
-export type OptionalKeymapId = 'toggleRenderedDocs';
+export type OptionalKeymapId =
+    | 'toggleRenderedDocs'
+    | 'increaseFontSize'
+    | 'decreaseFontSize'
+    | 'resetFontSize'
+    | 'sortLines'
+    | 'reverseLines'
+    | 'uniqueLines'
+    | 'convertIndentsToSpaces'
+    | 'convertIndentsToTabs';
 
 export type Keymap = Readonly<Record<Exclude<KeymapId, OptionalKeymapId>, KeyBinding> & Partial<Record<OptionalKeymapId, KeyBinding>>>;
 export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;

package/src/keymap.ts

@@ -52,6 +52,11 @@ const ACTIONS: Partial<Record<KeymapId, KeyAction>> = {
     splitLine: command('splitLine'),
     toggleCase: command('toggleCase'),
     autoIndentLines: command('autoIndentLines'),
+    sortLines: command('sortLines'),
+    reverseLines: command('reverseLines'),
+    uniqueLines: command('uniqueLines'),
+    convertIndentsToSpaces: command('convertIndentsToSpaces'),
+    convertIndentsToTabs: command('convertIndentsToTabs'),
     expandSelection: command('expandSelection'),
     shrinkSelection: command('shrinkSelection'),
     matchBrace: { type: 'bracket' },
@@ -87,7 +92,10 @@ const ACTIONS: Partial<Record<KeymapId, KeyAction>> = {
     expandAllToLevel3: view('expandAllToLevel3'),
     expandAllToLevel4: view('expandAllToLevel4'),
     expandAllToLevel5: view('expandAllToLevel5'),
-    toggleColumnMode: view('toggleColumnMode')
+    toggleColumnMode: view('toggleColumnMode'),
+    increaseFontSize: view('increaseFontSize'),
+    decreaseFontSize: view('decreaseFontSize'),
+    resetFontSize: view('resetFontSize')
 };
 
 const PUNCTUATION_CODES: Readonly<Record<string, string>> = {

package/src/overview.ts

@@ -1,4 +1,4 @@
-export type OverviewKind = 'added' | 'modified' | 'deleted' | 'find' | 'find-current' | 'occurrence' | 'info' | 'warning' | 'error';
+export type OverviewKind = 'added' | 'modified' | 'deleted' | 'find' | 'find-current' | 'occurrence' | 'todo' | 'info' | 'warning' | 'error';
 
 /* A stretch of the content, in the pixels the content is laid out in. */
 export interface OverviewSpan {