@adecore/editor-react 0.39.0 → 0.40.1

package/src/snippet.ts

@@ -45,13 +45,16 @@ type Node =
     | { kind: 'variable'; name: string; body?: Node[]; transform?: SnippetTransform };
 
 export type SnippetVariableResolver = (name: string) => string | undefined;
+
 export interface SnippetTemplate {
     readonly source: string;
     render(resolve?: SnippetVariableResolver, variableTransforms?: readonly string[]): ParsedSnippet;
 }
+
 type FieldNode = Extract<Node, { kind: 'field' }>;
 
 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;
@@ -79,21 +82,26 @@ class SnippetParser {
         if (++this.depth > MAX_SNIPPET_DEPTH) {
             throw new SnippetLimitError();
         }
+
         const nodes: Node[] = [];
         let text = '';
+
         const flush = (): void => {
             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] ?? '')) {
                 text += this.source[this.at + 1];
                 this.at += 2;
             } else if (character === '$') {
                 const node = this.dollar();
+
                 if (node === null) {
                     text += '$';
                 } else {
@@ -105,8 +113,10 @@ class SnippetParser {
                 this.at++;
             }
         }
+
         flush();
         this.depth--;
+
         return nodes;
     }
 
@@ -114,93 +124,125 @@ class SnippetParser {
         if (++this.nodes > MAX_SNIPPET_NODES) {
             throw new SnippetLimitError();
         }
+
         nodes.push(node);
     }
 
     private dollar(): Node | null {
         const start = this.at++;
         const brace = this.source[this.at] === '{';
+
         if (brace) {
             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 = (): FieldNode => ({ 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();
         }
+
         if (next === ':') {
             this.at++;
             const body = this.sequence(true);
+
             if (this.source[this.at] === '}') {
                 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;
     }
 
     private choices(): string[] {
         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 === ',') {
                 if (values.length >= MAX_SNIPPET_NODES) {
                     throw new SnippetLimitError();
                 }
+
                 values.push('');
             } else {
                 values[values.length - 1] += character;
             }
         }
+
         this.at = Math.min(this.source.length, this.at + 2);
+
         return values;
     }
 }
 
 function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly string[]): ParsedSnippet {
     const definitions = new Map<number, FieldNode>();
+
     const collect = (nodes: readonly Node[]): void => {
         for (const node of nodes) {
             if (node.kind === 'field') {
                 const known = definitions.get(node.index);
+
                 if (
                     known === undefined ||
                     (known.body === undefined &&
@@ -210,16 +252,20 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
                     definitions.set(node.index, node);
                 }
             }
+
             if (node.kind !== 'text' && node.body !== undefined) {
                 collect(node.body);
             }
         }
     };
+
     collect(nodes);
+
     const fields = new Map<
         number,
         { index: number; ranges: SnippetRange[]; linked: SnippetRange[]; primary: number; parents: Set<number>; choices?: string[] }
     >();
+
     const stops: SnippetStop[] = [];
     const transforms: (SnippetRange & { transform: SnippetTransform })[] = [];
     let text = '';
@@ -228,55 +274,72 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
     let occurrence = 0;
     let tailEvent = 0;
     let tailOffset = -1;
+
     const recordTail = (range: SnippetRange): void => {
         if (range.start === range.end || range.tail === true) {
             tailEvent++;
             tailOffset = range.end;
         }
     };
+
     const append = (value: string): void => {
         if (text.length + value.length > MAX_SNIPPET_TEXT) {
             throw new SnippetLimitError();
         }
+
         text += value;
     };
+
     const render = (nodes: readonly Node[], linked: boolean, parents: readonly number[], visiting: ReadonlySet<number>): void => {
         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] ?? '');
@@ -284,6 +347,7 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
                     render(definition.body ?? [], linked || node !== definition, [...parents, node.index], new Set([...visiting, node.index]));
                 }
             }
+
             const range: SnippetRange = {
                 start: from,
                 end: text.length,
@@ -291,8 +355,10 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
                 ...(node.transform === undefined ? {} : { transform: node.transform }),
                 ...(tailEvent !== beforeTail && tailOffset === text.length ? { tail: true as const } : {})
             };
+
             withSnippetOrder(range, order);
             recordTail(range);
+
             const field = fields.get(node.index) ?? {
                 index: node.index,
                 ranges: [],
@@ -301,14 +367,18 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
                 parents: new Set<number>(),
                 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(
                         {
@@ -322,14 +392,19 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
                     )
                 );
             }
+
             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,
@@ -350,6 +425,7 @@ function renderSnippet(nodes: readonly Node[], variableTransforms?: readonly str
 function variableIndices(nodes: readonly Node[]): ReadonlyMap<string, number> {
     let highest = 0;
     const names = new Set<string>();
+
     const scan = (nodes: readonly Node[]): void => {
         for (const node of nodes) {
             if (node.kind === 'field') {
@@ -357,17 +433,21 @@ function variableIndices(nodes: readonly Node[]): ReadonlyMap<string, number> {
             } 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];
         })
     );
@@ -376,16 +456,20 @@ function variableIndices(nodes: readonly Node[]): ReadonlyMap<string, number> {
 function resolveVariables(nodes: readonly Node[], indices: ReadonlyMap<string, number>, resolve?: SnippetVariableResolver): Node[] {
     const unknown = new Map<string, { index: number; body: Node[]; defaulted: boolean; definition: Node }>();
     const values = new Map<string, string | undefined>();
+
     const valueOf = (name: string): string | undefined => {
         if (!values.has(name)) {
             values.set(name, resolve?.(name));
         }
+
         return values.get(name);
     };
+
     const collect = (nodes: readonly Node[]): void => {
         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)!,
@@ -401,34 +485,44 @@ function resolveVariables(nodes: readonly Node[], indices: ReadonlyMap<string, n
                     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: readonly Node[], visiting: ReadonlySet<string>, depth = 0): Node[] => {
         if (depth > MAX_SNIPPET_DEPTH) {
             throw new SnippetLimitError();
         }
+
         return nodes.flatMap((node): 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',
@@ -440,15 +534,18 @@ function resolveVariables(nodes: readonly Node[], indices: ReadonlyMap<string, n
                     }
                 ];
             }
+
             return [node];
         });
     };
+
     return normalize(nodes, new Set());
 }
 
 export function compileSnippet(source: string): SnippetTemplate {
     let nodes: Node[] | null = null;
     let indices: ReadonlyMap<string, number> = new Map();
+
     if (source.length <= MAX_SNIPPET_TEXT) {
         try {
             nodes = new SnippetParser(source).parse();
@@ -457,24 +554,29 @@ export function compileSnippet(source: string): SnippetTemplate {
             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 };
             }
@@ -489,13 +591,16 @@ export function parseSnippet(snippet: string, resolve?: SnippetVariableResolver)
 /* One defining occurrence per index, then $0 or the end of the inserted text. */
 export function tabOrder(parsed: ParsedSnippet): SnippetStop[] {
     const first = new Map<number, SnippetStop>();
+
     for (const stop of parsed.stops) {
         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,
@@ -505,6 +610,8 @@ export function tabOrder(parsed: ParsedSnippet): SnippetStop[] {
             });
         }
     }
+
     const visited = [...first.values()].filter((stop) => stop.index > 0).sort((left, right) => left.index - right.index);
+
     return [...visited, first.get(0) ?? { index: 0, start: parsed.text.length, end: parsed.text.length }];
 }

package/src/split-alignment.ts

@@ -10,36 +10,46 @@ export function splitAlignment(
 ): { old: HostedRow[]; new: HostedRow[] } {
     const rows: { old: HostedRow[]; new: HostedRow[] } = { old: [], new: [] };
     const previous = { old: -1, new: -1 };
+
     const add = (side: 'old' | 'new', index: number, height: number, gap?: number): void => {
         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/src/split-scroll.ts

@@ -23,14 +23,18 @@ export class SplitScroll {
         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();
     }
 
@@ -39,11 +43,15 @@ export class SplitScroll {
         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 {

package/src/symbol-links.ts

@@ -1,4 +1,5 @@
 import type { Location, SymbolInformation, WorkspaceSymbol, WorkspaceSymbolResult } from '@adecore/lsp';
+import { uniqueBy } from './unique.ts';
 
 /* The classes a name in a signature has: a pointer and an underline on hover, and the accent only then, so the signature stays calm. */
 export const SYMBOL_LINK_CLASS = 'cursor-pointer hover:text-accent hover:underline';
@@ -46,27 +47,23 @@ export function placesOfName(result: WorkspaceSymbolResult, name: string, fileTe
     const found: Found[] = ((result ?? []) as (SymbolInformation | WorkspaceSymbol)[]).filter((symbol) => symbol.name === name);
     const types = found.filter((symbol) => TYPE_KINDS.has(symbol.kind));
     let candidates = types.length > 0 ? types : found;
+
     if (candidates.length > 1) {
         const named = candidates.filter(
             (symbol) => symbol.containerName !== undefined && symbol.containerName !== '' && fileText.includes(symbol.containerName)
         );
+
         if (named.length > 0) {
             candidates = named;
         }
     }
-    const seen = new Set<string>();
-    return candidates
-        .map((symbol): Location =>
+
+    return uniqueBy(
+        candidates.map((symbol): Location =>
             'range' in symbol.location
                 ? symbol.location
                 : { uri: symbol.location.uri, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } } }
-        )
-        .filter((location) => {
-            const key = `${location.uri}\0${location.range.start.line}`;
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        });
+        ),
+        (location) => `${location.uri}\0${location.range.start.line}`
+    );
 }