@adecore/editor-core 0.39.0 → 0.40.0

package/src/brackets.ts

@@ -1,18 +1,4 @@
-import {
-    hasBlockComments,
-    hasDashComments,
-    hasHashComments,
-    hashNeedsWordStart,
-    hasMarkupComments,
-    hasSlashComments,
-    isPhp,
-    isScript,
-    isWordCharacter,
-    openers,
-    startsExpressionAfter,
-    startsExpressionAt,
-    startsWord
-} from './lexical.ts';
+import { isWordCharacter, lexerRules, type LexerRules, openers, startsExpressionAfter, startsExpressionAt, startsWord } from './lexical.ts';
 
 export interface BracketIndex {
     /* Both directions: an opener maps to its closer and the closer back to the opener. */
@@ -44,17 +30,6 @@ export interface BracketState {
     stack: OpenBracket | undefined;
 }
 
-export interface BracketRules {
-    script: boolean;
-    hash: boolean;
-    hashAtWordStart: boolean;
-    dash: boolean;
-    phpAttributes: boolean;
-    slash: boolean;
-    block: boolean;
-    markup: boolean;
-}
-
 export interface BracketVisitor {
     open(at: number, depth: number): void;
     /* `depth` counts the opener it closes. */
@@ -67,37 +42,29 @@ export function initialBracketState(): BracketState {
     return { mode: 'code', quote: '', inClass: false, expression: true, stack: undefined };
 }
 
-export function bracketRules(language: string): BracketRules {
-    return {
-        script: isScript(language),
-        hash: hasHashComments(language),
-        hashAtWordStart: hashNeedsWordStart(language),
-        dash: hasDashComments(language),
-        phpAttributes: isPhp(language),
-        slash: hasSlashComments(language),
-        block: hasBlockComments(language),
-        markup: hasMarkupComments(language)
-    };
-}
-
 export function sameBracketState(left: BracketState, right: BracketState): boolean {
     if (left.mode !== right.mode || left.quote !== right.quote || left.inClass !== right.inClass || left.expression !== right.expression) {
         return false;
     }
+
     let one = left.stack;
     let other = right.stack;
+
     while (one !== other) {
         if (one === undefined || other === undefined || one.close !== other.close || one.template !== other.template || one.depth !== other.depth) {
             return false;
         }
+
         one = one.previous;
         other = other.previous;
     }
+
     return true;
 }
 
 function isSpace(character: string): boolean {
     const code = character.charCodeAt(0);
+
     return code === 32 || (code >= 9 && code <= 13) || (code > 127 && /\s/.test(character));
 }
 
@@ -108,10 +75,13 @@ function isCloser(character: string): boolean {
 /* Where a comment that runs to `terminator` ends in `text`, or `to` when it goes on past it. */
 function commentEnd(state: BracketState, text: string, at: number, to: number, terminator: string): number {
     const end = text.indexOf(terminator, at);
+
     if (end < 0 || end + terminator.length > to) {
         return to;
     }
+
     state.mode = 'code';
+
     return end + terminator.length - 1;
 }
 
@@ -119,25 +89,31 @@ function commentEnd(state: BracketState, text: string, at: number, to: number, t
  * Lexes `text` from `from` to `to`, continuing `state`, and reports every bracket of the code at its offset plus
  * `offset`. A piece has to end at a line break or the end of the text, as nothing here looks past one.
  */
-export function lexBrackets(state: BracketState, rules: BracketRules, text: string, from: number, to: number, offset: number, visitor: BracketVisitor): void {
+export function lexBrackets(state: BracketState, rules: LexerRules, text: string, from: number, to: number, offset: number, visitor: BracketVisitor): void {
     for (let at = from; at < to; at++) {
         const char = text[at]!;
+
         if (state.mode !== 'code') {
             switch (state.mode) {
                 case 'line-comment': {
                     const end = text.indexOf('\n', at);
+
                     if (end < 0 || end >= to) {
                         return;
                     }
+
                     state.mode = 'code';
                     at = end;
+
                     continue;
                 }
                 case 'block-comment':
                     at = commentEnd(state, text, at, to, '*/');
+
                     continue;
                 case 'markup-comment':
                     at = commentEnd(state, text, at, to, '-->');
+
                     continue;
                 case 'string':
                     if (char === '\\') {
@@ -145,6 +121,7 @@ export function lexBrackets(state: BracketState, rules: BracketRules, text: stri
                     } else if (char === state.quote || (rules.script && (char === '\n' || char === '\r'))) {
                         state.mode = 'code';
                     }
+
                     continue;
                 case 'template':
                     if (char === '\\') {
@@ -160,6 +137,7 @@ export function lexBrackets(state: BracketState, rules: BracketRules, text: stri
                         state.expression = true;
                         visitor.open(offset + at, depth);
                     }
+
                     continue;
                 case 'regex':
                     if (char === '\\') {
@@ -171,22 +149,26 @@ export function lexBrackets(state: BracketState, rules: BracketRules, text: stri
                     } else if ((char === '/' && !state.inClass) || char === '\n' || char === '\r') {
                         state.mode = 'code';
                     }
+
                     continue;
             }
+
             continue;
         }
 
         if (isSpace(char)) {
             continue;
         }
+
         const next = text[at + 1];
+
         if (rules.markup && char === '<' && text.startsWith('<!--', at)) {
             state.mode = 'markup-comment';
             at += 3;
         } else if (
             (rules.slash && char === '/' && next === '/') ||
             (rules.dash && char === '-' && next === '-') ||
-            (rules.hash && char === '#' && !(rules.phpAttributes && next === '[') && (!rules.hashAtWordStart || startsWord(text, at)))
+            (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at)))
         ) {
             state.mode = 'line-comment';
         } else if (rules.block && char === '/' && next === '*') {
@@ -209,22 +191,28 @@ export function lexBrackets(state: BracketState, rules: BracketRules, text: stri
             visitor.open(offset + at, depth);
         } else if (isCloser(char)) {
             const open = state.stack;
+
             if (open?.close === char) {
                 state.stack = open.previous;
+
                 if (open.template) {
                     state.mode = 'template';
                 }
+
                 visitor.close(offset + at, open.depth);
             } else {
                 state.stack = undefined;
                 visitor.mismatch(offset + at);
             }
+
             state.expression = false;
         } else if (isWordCharacter(char)) {
             const start = at;
+
             while (at + 1 < to && isWordCharacter(text[at + 1]!)) {
                 at++;
             }
+
             state.expression = startsExpressionAt(text, start, at + 1);
         } else {
             state.expression = startsExpressionAfter(char);
@@ -237,7 +225,8 @@ export function scanBrackets(text: string, language = 'typescript'): BracketInde
     const pairs = new Map<number, number>();
     const unmatched = new Set<number>();
     let open: number[] = [];
-    lexBrackets(initialBracketState(), bracketRules(language), text, 0, text.length, 0, {
+
+    lexBrackets(initialBracketState(), lexerRules(language), text, 0, text.length, 0, {
         open(at) {
             open.push(at);
         },
@@ -248,15 +237,19 @@ export function scanBrackets(text: string, language = 'typescript'): BracketInde
         },
         mismatch(at) {
             unmatched.add(at);
+
             // A mismatched closer keeps a distant opener from claiming it later.
             for (const abandoned of open) {
                 unmatched.add(abandoned);
             }
+
             open = [];
         }
     });
+
     for (const at of open) {
         unmatched.add(at);
     }
+
     return { pairs, unmatched };
 }

package/src/closer-tracker.ts

@@ -17,12 +17,12 @@ export class CloserTracker {
 
     add(open: number, close: number): void {
         this.marks.push({ open, close });
+
         if (this.marks.length > maxMarks) {
             this.marks.shift();
         }
     }
 
-    /* The closer that sits at `offset`, which a Tab there steps over. */
     isCloserAt(offset: number): boolean {
         return this.marks.some((mark) => mark.close === offset);
     }
@@ -31,6 +31,7 @@ export class CloserTracker {
         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 }];
         });
     }
@@ -47,14 +48,18 @@ export class CloserTracker {
 /* Null when an edit replaced the character at `offset`. */
 function mapThrough(offset: number, edits: readonly TextEdit[]): number | null {
     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;
 }