@adecore/editor-react 0.22.1 → 0.23.0

package/dist/snippet.js

@@ -1,134 +1,449 @@
-const NAME = '[A-Za-z_]\\w*';
-const TABSTOP = new RegExp(`^\\$(\\d+)|^\\$\\{(\\d+)\\}`);
-const PLACEHOLDER = /^\$\{(\d+):/;
-const CHOICE = /^\$\{(\d+)\|/;
-const DEFAULT_VARIABLE = new RegExp(`^\\$\\{${NAME}:`);
-const TRANSFORMED_VARIABLE = new RegExp(`^\\$\\{${NAME}/`);
-const BARE_VARIABLE = new RegExp(`^\\$${NAME}|^\\$\\{${NAME}\\}`);
+import { withSnippetOrder } from './snippet-range-order.js';
+import { scanSnippetTransform } from './snippet-transform-format.js';
+import { SNIPPET_VARIABLES } from './snippet-variable-names.js';
+export const MAX_SNIPPET_TEXT = 100_000;
+const MAX_SNIPPET_NODES = 10_000;
+const MAX_SNIPPET_WORK = 50_000;
+const MAX_SNIPPET_RANGES = 1_000;
+const MAX_SNIPPET_DEPTH = 64;
+class SnippetLimitError extends Error {
+}
+class MalformedSnippetError extends Error {
+}
 class SnippetParser {
-    text = '';
-    stops = [];
     at = 0;
+    nodes = 0;
+    depth = 0;
+    name = /(?:\d+|[A-Za-z_]\w*)/y;
     source;
     constructor(source) {
         this.source = source;
     }
     parse() {
-        this.sequence(false);
-        return { text: this.text, stops: this.stops };
+        return this.sequence(false);
     }
-    /* Text up to the `}` that closes the placeholder this is in, which is left for the caller. */
     sequence(nested) {
-        while (this.at < this.source.length) {
-            const character = this.source[this.at];
-            if (character === '}' && nested) {
-                return;
+        if (++this.depth > MAX_SNIPPET_DEPTH) {
+            throw new SnippetLimitError();
+        }
+        const nodes = [];
+        let text = '';
+        const flush = () => {
+            if (text !== '') {
+                this.push(nodes, { kind: 'text', text });
+                text = '';
             }
+        };
+        while (this.at < this.source.length && !(nested && this.source[this.at] === '}')) {
+            const character = this.source[this.at];
             if (character === '\\' && /[\\$}]/.test(this.source[this.at + 1] ?? '')) {
-                this.text += this.source[this.at + 1];
+                text += this.source[this.at + 1];
                 this.at += 2;
             }
             else if (character === '$') {
-                this.dollar();
+                const node = this.dollar();
+                if (node === null) {
+                    text += '$';
+                }
+                else {
+                    flush();
+                    this.push(nodes, node);
+                }
             }
             else {
-                this.text += character;
+                text += character;
                 this.at++;
             }
         }
+        flush();
+        this.depth--;
+        return nodes;
+    }
+    push(nodes, node) {
+        if (++this.nodes > MAX_SNIPPET_NODES) {
+            throw new SnippetLimitError();
+        }
+        nodes.push(node);
     }
     dollar() {
-        const rest = this.source.slice(this.at);
-        const tabstop = TABSTOP.exec(rest);
-        const placeholder = PLACEHOLDER.exec(rest);
-        const choice = CHOICE.exec(rest);
-        if (tabstop !== null) {
-            this.at += tabstop[0].length;
-            this.stops.push({ index: Number(tabstop[1] ?? tabstop[2]), start: this.text.length, end: this.text.length });
-        }
-        else if (placeholder !== null) {
-            this.at += placeholder[0].length;
-            const start = this.text.length;
-            this.sequence(true);
-            this.closeBrace();
-            this.stops.push({ index: Number(placeholder[1]), start, end: this.text.length });
-        }
-        else if (choice !== null) {
-            this.at += choice[0].length;
-            const start = this.text.length;
-            this.firstChoice();
-            this.stops.push({ index: Number(choice[1]), start, end: this.text.length });
-        }
-        else if (DEFAULT_VARIABLE.test(rest)) {
-            this.at += rest.indexOf(':') + 1;
-            this.sequence(true);
-            this.closeBrace();
-        }
-        else if (TRANSFORMED_VARIABLE.test(rest)) {
-            this.skipBraces();
-        }
-        else if (BARE_VARIABLE.test(rest)) {
-            this.at += BARE_VARIABLE.exec(rest)[0].length;
-        }
-        else {
-            this.text += '$';
+        const start = this.at++;
+        const brace = this.source[this.at] === '{';
+        if (brace) {
             this.at++;
         }
-    }
-    closeBrace() {
-        if (this.source[this.at] === '}') {
+        this.name.lastIndex = this.at;
+        const name = this.name.exec(this.source)?.[0];
+        if (name === undefined) {
+            this.at = start + 1;
+            return null;
+        }
+        const index = /^\d+$/.test(name) ? Number(name) : null;
+        if (index !== null && !Number.isSafeInteger(index)) {
+            this.at = start + 1;
+            return null;
+        }
+        this.at += name.length;
+        const field = () => ({ kind: 'field', index: index });
+        if (!brace) {
+            return index === null ? { kind: 'variable', name } : field();
+        }
+        const next = this.source[this.at];
+        if (next === '}') {
             this.at++;
+            return index === null ? { kind: 'variable', name } : field();
         }
-    }
-    /* The first of `a,b,c|}`, and the rest dropped. */
-    firstChoice() {
-        let first = true;
-        while (this.at < this.source.length && !(this.source[this.at] === '|' && this.source[this.at + 1] === '}')) {
-            const character = this.source[this.at];
-            if (character === '\\' && /[\\,|]/.test(this.source[this.at + 1] ?? '')) {
+        if (next === ':') {
+            this.at++;
+            const body = this.sequence(true);
+            if (this.source[this.at] === '}') {
                 this.at++;
-                if (first) {
-                    this.text += this.source[this.at];
+            }
+            return index === null ? { kind: 'variable', name, body } : { ...field(), body };
+        }
+        if (next === '|' && index !== null) {
+            this.at++;
+            return { ...field(), choices: this.choices() };
+        }
+        if (next === '/') {
+            try {
+                const { end, ...transform } = scanSnippetTransform(this.source, this.at);
+                this.at = end;
+                return index === null ? { kind: 'variable', name, transform } : { ...field(), transform };
+            }
+            catch (error) {
+                if (error instanceof RangeError) {
+                    throw new SnippetLimitError();
+                }
+                if (error instanceof SyntaxError) {
+                    throw new MalformedSnippetError();
                 }
+                throw error;
+            }
+        }
+        this.at = start + 1;
+        return null;
+    }
+    choices() {
+        const values = [''];
+        while (this.at < this.source.length && !(this.source[this.at] === '|' && this.source[this.at + 1] === '}')) {
+            const character = this.source[this.at++];
+            if (character === '\\' && /[\\,|]/.test(this.source[this.at] ?? '')) {
+                values[values.length - 1] += this.source[this.at++];
             }
             else if (character === ',') {
-                first = false;
+                if (values.length >= MAX_SNIPPET_NODES) {
+                    throw new SnippetLimitError();
+                }
+                values.push('');
             }
-            else if (first) {
-                this.text += character;
+            else {
+                values[values.length - 1] += character;
             }
-            this.at++;
         }
-        this.at += 2;
+        this.at = Math.min(this.source.length, this.at + 2);
+        return values;
     }
-    /* Past the `}` that closes a `${name/regex/format/}` variable, which inserts nothing here. */
-    skipBraces() {
-        let depth = 0;
-        while (this.at < this.source.length) {
-            const character = this.source[this.at];
-            this.at += character === '\\' ? 2 : 1;
-            if (character === '{') {
-                depth++;
+}
+function renderSnippet(nodes, variableTransforms) {
+    const definitions = new Map();
+    const collect = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === 'field') {
+                const known = definitions.get(node.index);
+                if (known === undefined ||
+                    (known.body === undefined &&
+                        known.choices === undefined &&
+                        (node.body !== undefined || node.choices !== undefined || (known.transform !== undefined && node.transform === undefined)))) {
+                    definitions.set(node.index, node);
+                }
             }
-            else if (character === '}' && --depth === 0) {
-                return;
+            if (node.kind !== 'text' && node.body !== undefined) {
+                collect(node.body);
             }
         }
+    };
+    collect(nodes);
+    const fields = new Map();
+    const stops = [];
+    const transforms = [];
+    let text = '';
+    let work = 0;
+    let ranges = 0;
+    let occurrence = 0;
+    let tailEvent = 0;
+    let tailOffset = -1;
+    const recordTail = (range) => {
+        if (range.start === range.end || range.tail === true) {
+            tailEvent++;
+            tailOffset = range.end;
+        }
+    };
+    const append = (value) => {
+        if (text.length + value.length > MAX_SNIPPET_TEXT) {
+            throw new SnippetLimitError();
+        }
+        text += value;
+    };
+    const render = (nodes, linked, parents, visiting) => {
+        if (parents.length > MAX_SNIPPET_DEPTH) {
+            throw new SnippetLimitError();
+        }
+        for (const node of nodes) {
+            if (++work > MAX_SNIPPET_WORK) {
+                throw new SnippetLimitError();
+            }
+            const order = occurrence++;
+            if (node.kind === 'text') {
+                const start = text.length;
+                const value = node.transform === undefined || variableTransforms === undefined ? node.text : variableTransforms[transforms.length];
+                if (typeof value !== 'string') {
+                    throw new RangeError('The variable transform count does not match the snippet.');
+                }
+                append(value);
+                if (node.transform !== undefined) {
+                    if (++ranges > MAX_SNIPPET_RANGES) {
+                        throw new SnippetLimitError();
+                    }
+                    const range = { start, end: text.length, transform: node.transform, ...(parents.length === 0 ? {} : { parents: [...parents] }) };
+                    withSnippetOrder(range, order);
+                    transforms.push(range);
+                    recordTail(range);
+                }
+                continue;
+            }
+            if (node.kind === 'variable') {
+                render(node.body ?? [], linked, parents, visiting);
+                continue;
+            }
+            if (++ranges > MAX_SNIPPET_RANGES) {
+                throw new SnippetLimitError();
+            }
+            const definition = definitions.get(node.index);
+            const from = text.length;
+            const beforeTail = tailEvent;
+            if (!visiting.has(node.index)) {
+                if (definition.choices !== undefined) {
+                    append(definition.choices[0] ?? '');
+                }
+                else {
+                    render(definition.body ?? [], linked || node !== definition, [...parents, node.index], new Set([...visiting, node.index]));
+                }
+            }
+            const range = {
+                start: from,
+                end: text.length,
+                ...(parents.length === 0 ? {} : { parents: [...parents] }),
+                ...(node.transform === undefined ? {} : { transform: node.transform }),
+                ...(tailEvent !== beforeTail && tailOffset === text.length ? { tail: true } : {})
+            };
+            withSnippetOrder(range, order);
+            recordTail(range);
+            const field = fields.get(node.index) ?? {
+                index: node.index,
+                ranges: [],
+                linked: [],
+                primary: 0,
+                parents: new Set(),
+                choices: definition.choices
+            };
+            parents.filter((parent) => parent !== node.index).forEach((parent) => field.parents.add(parent));
+            if (linked) {
+                field.linked.push(range);
+            }
+            else {
+                if (node === definition) {
+                    field.primary = field.ranges.length;
+                }
+                field.ranges.push(range);
+                stops.push(withSnippetOrder({
+                    index: node.index,
+                    start: range.start,
+                    end: range.end,
+                    ...(node.transform === undefined ? {} : { transform: node.transform }),
+                    ...(range.tail === undefined ? {} : { tail: range.tail })
+                }, order));
+            }
+            fields.set(node.index, field);
+        }
+    };
+    render(nodes, false, [], new Set());
+    if (variableTransforms !== undefined && variableTransforms.length !== transforms.length) {
+        throw new RangeError('The variable transform count does not match the snippet.');
     }
+    stops.sort((left, right) => left.start - right.start || right.end - left.end);
+    return {
+        text,
+        stops,
+        ...(transforms.length === 0 ? {} : { transforms }),
+        fields: [...fields.values()]
+            .filter((field) => field.ranges.length > 0)
+            .map((field) => ({
+            index: field.index,
+            ranges: field.ranges,
+            primary: field.primary,
+            ...(field.linked.length === 0 ? {} : { linked: field.linked }),
+            ...(field.parents.size === 0 ? {} : { parents: [...field.parents] }),
+            ...(field.choices === undefined ? {} : { choices: field.choices })
+        }))
+    };
 }
-export function parseSnippet(snippet) {
-    return new SnippetParser(snippet).parse();
+function variableIndices(nodes) {
+    let highest = 0;
+    const names = new Set();
+    const scan = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === 'field') {
+                highest = Math.max(highest, node.index);
+            }
+            else if (node.kind === 'variable' && !SNIPPET_VARIABLES.has(node.name)) {
+                names.add(node.name);
+            }
+            if (node.kind !== 'text' && node.body !== undefined) {
+                scan(node.body);
+            }
+        }
+    };
+    scan(nodes);
+    return new Map([...names].map((name) => {
+        if (!Number.isSafeInteger(++highest)) {
+            throw new SnippetLimitError();
+        }
+        return [name, highest];
+    }));
 }
-/* The stops in the order Tab visits them: 1, 2 and on, one per index, then the final stop `$0`, which the end of the text stands in for. */
+function resolveVariables(nodes, indices, resolve) {
+    const unknown = new Map();
+    const values = new Map();
+    const valueOf = (name) => {
+        if (!values.has(name)) {
+            values.set(name, resolve?.(name));
+        }
+        return values.get(name);
+    };
+    const collect = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === 'variable' && valueOf(node.name) === undefined && !SNIPPET_VARIABLES.has(node.name)) {
+                const previous = unknown.get(node.name);
+                if (previous === undefined) {
+                    unknown.set(node.name, {
+                        index: indices.get(node.name),
+                        body: node.body ?? [{ kind: 'text', text: node.name }],
+                        defaulted: node.body !== undefined,
+                        definition: node
+                    });
+                }
+                else if (node.body !== undefined && !previous.defaulted) {
+                    previous.body = node.body;
+                    previous.defaulted = true;
+                    previous.definition = node;
+                }
+                else if (!previous.defaulted && node.transform === undefined && previous.definition.transform !== undefined) {
+                    previous.definition = node;
+                }
+            }
+            if (node.kind !== 'text' && node.body !== undefined) {
+                collect(node.body);
+            }
+        }
+    };
+    collect(nodes);
+    // Resolved empty variables retain their defaults without adding a navigable field.
+    let work = 0;
+    const normalize = (nodes, visiting, depth = 0) => {
+        if (depth > MAX_SNIPPET_DEPTH) {
+            throw new SnippetLimitError();
+        }
+        return nodes.flatMap((node) => {
+            if (++work > MAX_SNIPPET_WORK) {
+                throw new SnippetLimitError();
+            }
+            if (node.kind === 'variable' && !unknown.has(node.name)) {
+                const value = valueOf(node.name);
+                if (node.transform !== undefined) {
+                    return [{ kind: 'text', text: value ?? '', transform: node.transform }];
+                }
+                return value !== undefined && value !== '' ? [{ kind: 'text', text: value }] : normalize(node.body ?? [], visiting, depth + 1);
+            }
+            if (node.kind === 'field') {
+                return [{ ...node, ...(node.body === undefined ? {} : { body: normalize(node.body, visiting, depth + 1) }) }];
+            }
+            if (node.kind === 'variable') {
+                const field = unknown.get(node.name);
+                return [
+                    {
+                        kind: 'field',
+                        index: field.index,
+                        ...(node.transform === undefined ? {} : { transform: node.transform }),
+                        ...(node !== field.definition
+                            ? {}
+                            : { body: visiting.has(node.name) ? [] : normalize(field.body, new Set([...visiting, node.name]), depth + 1) })
+                    }
+                ];
+            }
+            return [node];
+        });
+    };
+    return normalize(nodes, new Set());
+}
+export function compileSnippet(source) {
+    let nodes = null;
+    let indices = new Map();
+    if (source.length <= MAX_SNIPPET_TEXT) {
+        try {
+            nodes = new SnippetParser(source).parse();
+            indices = variableIndices(nodes);
+        }
+        catch (error) {
+            if (error instanceof MalformedSnippetError) {
+                return { source, render: () => ({ text: source, stops: [] }) };
+            }
+            if (!(error instanceof SnippetLimitError)) {
+                throw error;
+            }
+            nodes = null;
+        }
+    }
+    return {
+        source,
+        render: (resolve, variableTransforms) => {
+            if (nodes === null) {
+                return { text: source, stops: [], limited: true };
+            }
+            try {
+                return renderSnippet(resolveVariables(nodes, indices, resolve), variableTransforms);
+            }
+            catch (error) {
+                if (!(error instanceof SnippetLimitError)) {
+                    throw error;
+                }
+                // Language-server snippets may expand exponentially; retain the original text without a session.
+                return { text: source, stops: [], limited: true };
+            }
+        }
+    };
+}
+export function parseSnippet(snippet, resolve) {
+    return compileSnippet(snippet).render(resolve);
+}
+/* One defining occurrence per index, then $0 or the end of the inserted text. */
 export function tabOrder(parsed) {
     const first = new Map();
     for (const stop of parsed.stops) {
-        const known = first.get(stop.index);
-        if (known === undefined || stop.start < known.start) {
+        if (!first.has(stop.index)) {
             first.set(stop.index, stop);
         }
     }
+    for (const field of parsed.fields ?? []) {
+        const range = field.ranges[field.primary];
+        if (range !== undefined) {
+            first.set(field.index, {
+                index: field.index,
+                start: range.start,
+                end: range.end,
+                ...(range.transform === undefined ? {} : { transform: range.transform })
+            });
+        }
+    }
     const visited = [...first.values()].filter((stop) => stop.index > 0).sort((left, right) => left.index - right.index);
-    const final = first.get(0) ?? { index: 0, start: parsed.text.length, end: parsed.text.length };
-    return [...visited, final];
+    return [...visited, first.get(0) ?? { index: 0, start: parsed.text.length, end: parsed.text.length }];
 }

package/dist/split-alignment.d.ts

@@ -0,0 +1,6 @@
+import type { DiffSplitRow } from '@adecore/merge';
+import type { HostedRow } from './row-host.ts';
+export declare function splitAlignment(aligned: readonly DiffSplitRow[], oldHeight: (line: number) => number, newHeight: (line: number) => number, gapHeight?: number): {
+    old: HostedRow[];
+    new: HostedRow[];
+};

package/dist/split-alignment.js

@@ -0,0 +1,38 @@
+/* Intrinsic heights exclude spacers, so repeated alignment converges without adding its own padding. */
+export function splitAlignment(aligned, oldHeight, newHeight, gapHeight = 32) {
+    const rows = { old: [], new: [] };
+    const previous = { old: -1, new: -1 };
+    const add = (side, index, height, gap) => {
+        if (height <= 0) {
+            return;
+        }
+        const line = Math.max(0, previous[side]);
+        const placement = previous[side] < 0 ? 'above' : 'below';
+        const last = rows[side].at(-1);
+        if (gap === undefined && last?.filler && last.line === line && last.placement === placement) {
+            last.height += height;
+        }
+        else {
+            rows[side].push({ id: gap === undefined ? `spacer-${index}` : `gap-${gap}`, line, placement, height, fixed: true, filler: gap === undefined });
+        }
+    };
+    for (const [index, entry] of aligned.entries()) {
+        if (entry.kind === 'gap') {
+            add('old', index, gapHeight, entry.row.id);
+            add('new', index, gapHeight, entry.row.id);
+            continue;
+        }
+        const old = entry.old === undefined ? 0 : oldHeight(entry.old);
+        const fresh = entry.new === undefined ? 0 : newHeight(entry.new);
+        if (entry.old !== undefined) {
+            previous.old = entry.old;
+        }
+        if (entry.new !== undefined) {
+            previous.new = entry.new;
+        }
+        const target = Math.max(old, fresh);
+        add('old', index, target - old);
+        add('new', index, target - fresh);
+    }
+    return rows;
+}

package/dist/split-scroll.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from '@adecore/editor';
+import type { DiffSourceSide } from './diff-syntax.ts';
+type ScrollEditor = Pick<Editor, 'getScrollTop' | 'setScrollTop'>;
+export declare class SplitScroll {
+    private leader;
+    private syncing;
+    private readonly expected;
+    private readonly editors;
+    constructor(editors: Record<DiffSourceSide, ScrollEditor>);
+    drive(side: DiffSourceSide): void;
+    changed(side: DiffSourceSide): void;
+    sync(): void;
+}
+export {};

package/dist/split-scroll.js

@@ -0,0 +1,45 @@
+export class SplitScroll {
+    leader = 'new';
+    syncing = false;
+    expected;
+    editors;
+    constructor(editors) {
+        this.editors = editors;
+        this.expected = { old: editors.old.getScrollTop(), new: editors.new.getScrollTop() };
+    }
+    drive(side) {
+        this.leader = side;
+    }
+    changed(side) {
+        if (this.syncing) {
+            return;
+        }
+        const top = this.editors[side].getScrollTop();
+        if (side !== this.leader) {
+            // Native scroll echoes arrive after setScrollTop returns, including a clamped follower position.
+            if (Math.abs(top - this.expected[side]) < 1) {
+                return;
+            }
+            this.leader = side;
+        }
+        this.sync();
+    }
+    sync() {
+        const side = this.leader;
+        const other = side === 'old' ? 'new' : 'old';
+        const top = this.editors[side].getScrollTop();
+        this.expected[side] = top;
+        if (Math.abs(this.editors[other].getScrollTop() - top) < 1) {
+            this.expected[other] = this.editors[other].getScrollTop();
+            return;
+        }
+        this.syncing = true;
+        try {
+            this.editors[other].setScrollTop(top);
+        }
+        finally {
+            this.expected[other] = this.editors[other].getScrollTop();
+            this.syncing = false;
+        }
+    }
+}

package/dist/symbols.d.ts

@@ -6,9 +6,10 @@ export interface SymbolSpan {
     readonly name: string;
     readonly kind: number;
     readonly range: Range;
+    readonly nameLine?: number;
 }
 export declare function symbolSpansOf(result: DocumentSymbolResult): SymbolSpan[];
-export declare function blocksOf(result: DocumentSymbolResult): EditorBlock[];
+export declare function blocksOf(result: DocumentSymbolResult, text?: string): EditorBlock[];
 export declare class SymbolsFeature {
     private readonly refresher;
     private readonly listeners;