@adecore/editor-core 0.0.1 → 0.17.0-beta.2

package/dist/closer-tracker.js

@@ -0,0 +1,46 @@
+const limit = 64;
+/*
+ * The closers the editor inserted by itself and the caret has not left yet, which Tab steps over. A
+ * mark follows its opener and closer through edits and goes as soon as an edit replaces either one
+ * or no caret sits inside the pair any more.
+ */
+export class CloserTracker {
+    marks = [];
+    add(open, close) {
+        this.marks.push({ open, close });
+        if (this.marks.length > limit) {
+            this.marks.shift();
+        }
+    }
+    /* The closer that sits at `offset`, which a Tab there steps over. */
+    isCloserAt(offset) {
+        return this.marks.some((mark) => mark.close === offset);
+    }
+    map(edits) {
+        this.marks = this.marks.flatMap((mark) => {
+            const open = mapThrough(mark.open, edits);
+            const close = mapThrough(mark.close, edits);
+            return open === null || close === null ? [] : [{ open, close }];
+        });
+    }
+    prune(selections) {
+        this.marks = this.marks.filter((mark) => selections.some((selection) => selection.head > mark.open && selection.head <= mark.close));
+    }
+    clear() {
+        this.marks = [];
+    }
+}
+/* Null when an edit replaced the character at `offset`. */
+function mapThrough(offset, edits) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (offset < edit.from) {
+            break;
+        }
+        if (offset < edit.to) {
+            return null;
+        }
+        delta += edit.text.length - (edit.to - edit.from);
+    }
+    return offset + delta;
+}

package/dist/comments.d.ts

@@ -0,0 +1,14 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection } from './types.ts';
+export interface CommentOptions {
+    language: string;
+    tabSize: number;
+    insertSpaces: boolean;
+    lineToken?: string;
+    lineSpan?: (line: number) => {
+        first: number;
+        last: number;
+    };
+}
+export declare function planLineComments(source: EditSource, selections: readonly Selection[], options: CommentOptions): EditPlan | null;
+export declare function planBlockComment(source: EditSource, selections: readonly Selection[], options: CommentOptions): EditPlan | null;

package/dist/comments.js

@@ -0,0 +1,344 @@
+import { commentSyntax } from './languages.js';
+import { mapOffset } from './offsets.js';
+import { indentationColumn } from './structure.js';
+function whitespaceOf(text) {
+    return /^[\t ]*/.exec(text)[0];
+}
+function isBlank(text) {
+    return text.trim() === '';
+}
+function syntaxOf(source, options, line) {
+    const syntax = commentSyntax(options.language, source.region(line));
+    return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
+}
+function rangeOf(selection) {
+    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+}
+/* The runs of adjacent lines the selections touch. A selection that ends at the start of a line does not touch it. */
+function blocksOf(source, selections, span) {
+    const blocks = [];
+    const ordered = selections.map((selection, index) => ({ ...rangeOf(selection), index })).sort((left, right) => left.from - right.from);
+    for (const { from, to, index } of ordered) {
+        let first = source.lineAt(from);
+        let last = source.lineAt(to);
+        if (last > first && source.line(last).start === to) {
+            last--;
+        }
+        if (span) {
+            first = span(first).first;
+            last = Math.max(last, span(last).last);
+        }
+        const previous = blocks.at(-1);
+        if (previous && first <= previous.last + 1) {
+            previous.last = Math.max(previous.last, last);
+            previous.carets.push(index);
+        }
+        else {
+            blocks.push({ first, last, carets: [index] });
+        }
+    }
+    return blocks;
+}
+function isCommented(text, syntax, multiline) {
+    const trimmed = text.trim();
+    if (syntax.line !== null) {
+        return trimmed.startsWith(syntax.line.trimEnd());
+    }
+    const block = syntax.block;
+    if (trimmed === '') {
+        return multiline;
+    }
+    return trimmed.length >= block.open.length + block.close.length && trimmed.startsWith(block.open) && trimmed.endsWith(block.close);
+}
+function indentText(width, options) {
+    if (options.insertSpaces) {
+        return ' '.repeat(width);
+    }
+    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
+}
+/* The new place of a line after the edits, which never cross a line break. */
+function geometryOf(source, edits, index) {
+    const bounds = source.line(index);
+    const result = { start: bounds.start, length: bounds.end - bounds.start };
+    for (const edit of edits) {
+        const delta = edit.text.length - (edit.to - edit.from);
+        if (edit.from < bounds.start) {
+            result.start += delta;
+        }
+        else if (edit.to <= bounds.end) {
+            result.length += delta;
+        }
+    }
+    return result;
+}
+/*
+ * Comments the lines the selections touch, or takes the comment off when every non-blank one has it.
+ * The markers go in at the smallest indentation of the lines, and a lone caret moves to the next line.
+ */
+export function planLineComments(source, selections, options) {
+    const blocks = blocksOf(source, selections, options.lineSpan);
+    const syntaxes = blocks.map((block) => syntaxOf(source, options, block.first));
+    if (syntaxes.some((syntax) => syntax.line === null && syntax.block === null)) {
+        return null;
+    }
+    const lineBased = syntaxes.map((syntax) => (syntax.line === null ? syntax : { ...syntax, block: null }));
+    let allCommented = true;
+    let anyCommented = false;
+    for (const [position, block] of blocks.entries()) {
+        const single = block.first === block.last;
+        for (let line = block.first; line <= block.last; line++) {
+            const text = source.line(line).text;
+            const commented = isCommented(text, lineBased[position], !single);
+            if (commented && !isBlank(text)) {
+                anyCommented = true;
+            }
+            if (!commented && (single || !isBlank(text))) {
+                allCommented = false;
+            }
+        }
+        if (allCommented && !single && !anyCommented) {
+            allCommented = false;
+        }
+    }
+    const edits = [];
+    const placed = new Set();
+    for (const [position, block] of blocks.entries()) {
+        const syntax = lineBased[position];
+        const multiline = block.first !== block.last;
+        const startingNewLine = !multiline &&
+            block.carets.length === 1 &&
+            isBlank(source.line(block.first).text) &&
+            selections[block.carets[0]].anchor === selections[block.carets[0]].head;
+        const minimum = allCommented ? 0 : minimumIndent(source, block, syntax, options);
+        for (let line = block.first; line <= block.last; line++) {
+            const bounds = source.line(line);
+            const edit = allCommented
+                ? uncommentLine(bounds.start, bounds.text, syntax)
+                : commentLine(bounds.start, bounds.text, syntax, minimum, multiline, startingNewLine, options);
+            if (edit) {
+                edits.push(edit);
+                if (startingNewLine && !allCommented) {
+                    placed.add(line);
+                }
+            }
+        }
+    }
+    if (edits.length === 0) {
+        return null;
+    }
+    return { edits, selections: finalSelections(source, selections, blocks, edits, allCommented, placed, lineBased, options.lineSpan) };
+}
+function minimumIndent(source, block, syntax, options) {
+    let minimum = Number.POSITIVE_INFINITY;
+    for (let line = block.first; line <= block.last; line++) {
+        const text = source.line(line).text;
+        if (!isBlank(text)) {
+            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
+        }
+    }
+    if (block.first > 0) {
+        const previous = source.line(block.first - 1).text;
+        const marker = syntax.line ?? syntax.block?.open;
+        if (marker && previous.trimStart().startsWith(marker)) {
+            minimum = Math.min(minimum, indentationColumn(whitespaceOf(previous), options.tabSize));
+        }
+    }
+    return Number.isFinite(minimum) ? minimum : 0;
+}
+function commentLine(start, text, syntax, minimum, multiline, startingNewLine, options) {
+    const blank = isBlank(text);
+    if (syntax.line === null && blank && multiline) {
+        return null;
+    }
+    const leading = whitespaceOf(text);
+    let kept = 0;
+    let width = 0;
+    while (kept < leading.length && width < minimum) {
+        width += leading[kept] === '\t' ? options.tabSize - (width % options.tabSize) : 1;
+        kept++;
+    }
+    // A line whose whitespace ends before the indent does is padded out to it.
+    const short = width < minimum;
+    const padding = short ? indentText(minimum, options) : '';
+    const markerAt = start + (short ? leading.length : kept);
+    if (syntax.line !== null) {
+        const space = !blank || startingNewLine ? ' ' : '';
+        return { from: short ? start : markerAt, to: markerAt, text: padding + syntax.line + space };
+    }
+    const { open, close } = syntax.block;
+    const end = start + text.trimEnd().length;
+    const body = blank ? '' : text.slice(markerAt - start, end - start);
+    return { from: short ? start : markerAt, to: blank ? start + text.length : end, text: padding + open + (blank ? '  ' : ` ${body} `) + close };
+}
+function uncommentLine(start, text, syntax) {
+    const trimmed = text.trim();
+    if (trimmed === '') {
+        return null;
+    }
+    const leading = whitespaceOf(text);
+    let rest;
+    if (syntax.line !== null) {
+        const marker = syntax.line.trimEnd();
+        if (!trimmed.startsWith(marker)) {
+            return null;
+        }
+        const body = text.slice(leading.length + marker.length);
+        rest = body.startsWith(' ') ? body.slice(1) : body;
+    }
+    else {
+        const { open, close } = syntax.block;
+        if (!trimmed.startsWith(open) || !trimmed.endsWith(close)) {
+            return null;
+        }
+        const inner = text.trimEnd().slice(leading.length + open.length, -close.length);
+        rest = (inner.startsWith(' ') ? inner.slice(1) : inner).replace(/ $/, '');
+        rest += text.slice(text.trimEnd().length);
+    }
+    const kept = leading + rest;
+    if (kept.trim() === '') {
+        return { from: start, to: start + text.length, text: '' };
+    }
+    return { from: start + leading.length, to: start + text.length, text: rest };
+}
+function finalSelections(source, selections, blocks, edits, allCommented, placed, syntaxes, span) {
+    const sorted = [...edits].sort((left, right) => left.from - right.from);
+    const result = selections.map((selection) => ({
+        anchor: mapOffset(selection.anchor, sorted, true),
+        head: mapOffset(selection.head, sorted, true)
+    }));
+    const moveCarets = blocks.every((block) => block.carets.length === 1 || block.first === block.last);
+    if (!moveCarets) {
+        return result;
+    }
+    for (const [position, block] of blocks.entries()) {
+        for (const index of block.carets) {
+            const selection = selections[index];
+            const { from, to } = rangeOf(selection);
+            const line = source.lineAt(from);
+            if (from === to) {
+                result[index] = caretAfter(source, sorted, line, span?.(line).last ?? line, selection.head, allCommented, placed, syntaxes[position]);
+                continue;
+            }
+            const lastLine = source.lineAt(to - 1);
+            const whole = source.line(line).start === from && source.line(lastLine).next === to;
+            if (whole) {
+                const start = geometryOf(source, sorted, line).start;
+                result[index] =
+                    selection.anchor <= selection.head ? { anchor: start, head: result[index].head } : { anchor: result[index].anchor, head: start };
+            }
+        }
+    }
+    return result;
+}
+function caretAfter(source, edits, line, lastLine, offset, allCommented, placed, syntax) {
+    const geometry = geometryOf(source, edits, line);
+    if (placed.has(line) && !allCommented) {
+        const caret = syntax.line === null ? geometry.start + geometry.length - syntax.block.close.length - 1 : geometry.start + geometry.length;
+        return { anchor: caret, head: caret };
+    }
+    const mapped = mapOffset(offset, edits);
+    if (lastLine >= source.lineCount - 1) {
+        return { anchor: mapped, head: mapped };
+    }
+    const next = geometryOf(source, edits, lastLine + 1);
+    const column = Math.min(mapped - geometry.start, next.length);
+    return { anchor: next.start + column, head: next.start + column };
+}
+/* Where the comment that holds `offset` runs, for the markers the lexer knows. Null outside a comment. */
+function commentAround(source, offset, block) {
+    const context = source.context(offset);
+    if ((context.mode !== 'block-comment' && context.mode !== 'html-comment') || context.commentStart === undefined) {
+        return null;
+    }
+    const from = context.commentStart;
+    if (source.slice(from, from + block.open.length) !== block.open) {
+        return null;
+    }
+    const close = source.slice(from + block.open.length, from + block.open.length + 200_000).indexOf(block.close);
+    return close < 0 ? null : { from, to: from + block.open.length + close + block.close.length };
+}
+/* The comment a selection is, markers and all, or null. */
+function commentOf(source, from, to, block) {
+    const text = source.slice(from, to);
+    const start = text.length - text.trimStart().length;
+    const end = text.trimEnd().length;
+    const body = text.slice(start, end);
+    if (body.length >= block.open.length + block.close.length && body.startsWith(block.open) && body.endsWith(block.close)) {
+        return { from: from + start, to: from + end };
+    }
+    return null;
+}
+/*
+ * Wraps each selection in the block markers, or takes them off a comment the selection is or sits in.
+ * With nothing selected it opens an empty comment around the caret.
+ */
+export function planBlockComment(source, selections, options) {
+    const edits = [];
+    const result = [];
+    let offsetDelta = 0;
+    for (const selection of selections) {
+        const { from, to } = rangeOf(selection);
+        const block = syntaxOf(source, options, source.lineAt(from)).block;
+        if (!block) {
+            return null;
+        }
+        const found = commentOf(source, from, to, block) ?? commentAround(source, from, block);
+        if (found && from !== to && !(found.from >= from && found.to <= to)) {
+            return null;
+        }
+        if (found) {
+            const innerStart = found.from + block.open.length + (source.charAt(found.from + block.open.length) === ' ' ? 1 : 0);
+            const closeAt = found.to - block.close.length;
+            const innerEnd = closeAt - (source.charAt(closeAt - 1) === ' ' && closeAt - 1 >= innerStart ? 1 : 0);
+            edits.push({ from: found.from, to: innerStart, text: '' }, { from: innerEnd, to: found.to, text: '' });
+            const head = Math.min(Math.max(selection.head, innerStart), innerEnd);
+            const anchor = Math.min(Math.max(selection.anchor, innerStart), innerEnd);
+            const removedBefore = innerStart - found.from;
+            result.push({ anchor: anchor - removedBefore + offsetDelta, head: head - removedBefore + offsetDelta });
+            offsetDelta -= innerStart - found.from + (found.to - innerEnd);
+            continue;
+        }
+        if (source.slice(from, to).includes(block.close)) {
+            return null;
+        }
+        if (from === to) {
+            const text = `${block.open}  ${block.close}`;
+            edits.push({ from, to, text });
+            const caret = from + offsetDelta + block.open.length + 1;
+            result.push({ anchor: caret, head: caret });
+            offsetDelta += text.length;
+            continue;
+        }
+        const wrapped = wrapRange(source, from, to, block, options);
+        edits.push(...wrapped);
+        const added = wrapped.reduce((sum, edit) => sum + edit.text.length, 0);
+        result.push({ anchor: from + offsetDelta, head: to + added + offsetDelta });
+        offsetDelta += added;
+    }
+    return { edits, selections: result };
+}
+function wrapRange(source, from, to, block, options) {
+    const first = source.lineAt(from);
+    const last = source.lineAt(to - 1);
+    const endsLine = source.charAt(to - 1) === '\n' || to === source.line(source.lineCount - 1).end;
+    if (from !== source.line(first).start || !endsLine) {
+        return [
+            { from, to: from, text: `${block.open} ` },
+            { from: to, to, text: ` ${block.close}` }
+        ];
+    }
+    let minimum = Number.POSITIVE_INFINITY;
+    for (let line = first; line <= last; line++) {
+        const text = source.line(line).text;
+        if (!isBlank(text)) {
+            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
+        }
+    }
+    const space = indentText(Number.isFinite(minimum) ? minimum : 0, options);
+    const newline = source.newline(first);
+    const closing = source.charAt(to - 1) === '\n' ? `${space}${block.close}${newline}` : `${newline}${space}${block.close}`;
+    return [
+        { from, to: from, text: `${space}${block.open}${newline}` },
+        { from: to, to, text: closing }
+    ];
+}

package/dist/document.d.ts

@@ -0,0 +1,148 @@
+import type { DocumentLine } from './rope.ts';
+import type { FindMatch, FindNextOptions, FindOptions } from './search.ts';
+import type { FoldingOptions, FoldingRange } from './structure.ts';
+import type { CommandOptions, Disposable, EditOptions, EditorCommand, EditorSnapshot, Position, Selection, TextEdit } from './types.ts';
+export type { DocumentLine, FindMatch, FindNextOptions, FindOptions, FoldingOptions, FoldingRange };
+export interface OffsetRange {
+    readonly from: number;
+    readonly to: number;
+}
+export interface DocumentEditOptions extends EditOptions {
+    expectedRevision?: number;
+}
+export interface TypeTextOptions extends CommandOptions {
+    historyGroup?: string;
+    expectedRevision?: number;
+}
+export interface ReplaceOptions extends DocumentEditOptions {
+    literal?: boolean;
+    preserveCase?: boolean;
+}
+export interface ReplaceAllOptions extends FindOptions, ReplaceOptions {
+}
+export type VisualLineOf = (offset: number) => {
+    start: number;
+    end: number;
+};
+export declare class DocumentModel {
+    private rope;
+    private selections;
+    private revision;
+    private undoStack;
+    private redoStack;
+    private listeners;
+    private groupOpen;
+    private textCache;
+    private structureCache?;
+    private selectionHistory;
+    private typingContexts;
+    private statementClosers;
+    private cloneSession;
+    private occurrenceSession;
+    occurrencesExhausted: boolean;
+    private closers;
+    private bracketCache?;
+    constructor(text?: string);
+    getText(): string;
+    getLength(): number;
+    getRevision(): number;
+    getLineCount(): number;
+    getLine(line: number): DocumentLine;
+    slice(from: number, to: number): string;
+    getSelections(): readonly Selection[];
+    getSelectionCount(): number;
+    getPrimary(): Selection;
+    getSnapshot(): EditorSnapshot;
+    setSelections(selections: readonly Selection[]): void;
+    subscribe(listener: (snapshot: EditorSnapshot) => void): Disposable;
+    applyEdits(edits: readonly TextEdit[], options?: DocumentEditOptions): boolean;
+    setText(text: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    positionAt(offset: number): Position;
+    offsetAt(position: Position): number;
+    find(query: string, options?: FindOptions): FindMatch[];
+    findNext(query: string, from?: number, options?: FindNextOptions): FindMatch | null;
+    replace(match: FindMatch, replacement: string, options?: ReplaceOptions): boolean;
+    replaceAll(query: string, replacement: string, options?: ReplaceAllOptions): number;
+    getFoldingRanges(options?: FoldingOptions): FoldingRange[];
+    typeText(text: string, options?: TypeTextOptions): boolean;
+    paste(text: string, options?: CommandOptions & {
+        wholeLines?: boolean;
+    }): boolean;
+    execute(command: EditorCommand, options?: CommandOptions): boolean;
+    private validateEdits;
+    private planTyping;
+    private surroundSelection;
+    private dedentCloser;
+    private shouldClosePair;
+    private completesTripleQuote;
+    private hasMatch;
+    private rememberStatementClosers;
+    private rememberPairs;
+    private insertTab;
+    private columnOf;
+    private moveToLineEdge;
+    private firstNonSpace;
+    private homeOffset;
+    private smartIndentColumn;
+    private offsetAtColumn;
+    private endOffset;
+    private moveByWord;
+    private caretStop;
+    private foldedStop;
+    private nextLineStop;
+    private previousLineStop;
+    private addCaret;
+    private cloneSource;
+    private cloneOnto;
+    private changeLineIndentation;
+    private toggleComment;
+    private selectedLines;
+    private duplicate;
+    private deleteLines;
+    private moveLines;
+    private insertNewline;
+    private startNewLineBefore;
+    private editLines;
+    private editSource;
+    private bracketIndex;
+    private deleteCharacter;
+    private isEmptyPair;
+    private backspaceStart;
+    private deleteRanges;
+    private applySelectionEdits;
+    private newlineAt;
+    private escaped;
+    private typingContext;
+    private isInterpolation;
+    private semicolonTarget;
+    wordSelectionAt(offset: number, camel?: boolean): {
+        from: number;
+        to: number;
+    } | null;
+    private identifierRunAt;
+    wordStartBefore(offset: number, camel?: boolean): number;
+    wordEndAfter(offset: number, camel?: boolean): number;
+    private isBetweenBrackets;
+    private wordRange;
+    private expandSelection;
+    expandSelectionTo(ranges: readonly (OffsetRange | null)[]): boolean;
+    private largerRange;
+    private lexicalExpansion;
+    private shrinkSelection;
+    private occurrenceSignature;
+    private repeatedOccurrence;
+    private rememberOccurrence;
+    private overlapsSelection;
+    private selectNextOccurrence;
+    private unselectOccurrence;
+    private selectAllOccurrences;
+    private addCaretPerSelectedLine;
+    private changeSelections;
+    private structure;
+    private state;
+    private invalidate;
+    private restore;
+    private emit;
+}