@adecore/editor-core 0.39.0 → 0.40.0

package/src/typing-context.ts

@@ -1,18 +1,4 @@
-import {
-    hasBlockComments,
-    hasDashComments,
-    hasHashComments,
-    hashNeedsWordStart,
-    hasMarkupComments,
-    hasSlashComments,
-    isPhp,
-    isScript,
-    isWordCharacter,
-    openers,
-    startsExpression,
-    startsExpressionAfter,
-    startsWord
-} from './lexical.ts';
+import { isWordCharacter, lexerRules, type LexerRules as Rules, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.ts';
 import { scanPhpMarkup } from './php-markup.ts';
 import type { DocumentLine } from './rope.ts';
 
@@ -55,21 +41,11 @@ export interface TypingContext {
     phpClose?: number;
 }
 
-interface Rules {
-    script: boolean;
-    php: boolean;
-    hash: boolean;
-    hashAtWordStart: boolean;
-    dash: boolean;
-    slash: boolean;
-    block: boolean;
-    markup: boolean;
-}
-
 const PHP_HEREDOC = /^<<<[ \t]*(["']?)([A-Za-z_]\w*)\1[ \t]*$/;
 const PHP_OPEN = /<\?(?:php\b|=)/;
 const PHP_INITIAL_LINES = 64;
 const PHP_INITIAL_CHARACTERS = 64 * 1024;
+
 // Quoted PHP tags within a bare code fragment must not turn its prelude into output.
 const PHP_FRAGMENT_START =
     /^(?:[$'"#]|\/[/*]|(?:abstract|class|const|declare|echo|enum|final|for|foreach|function|if|include(?:_once)?|interface|namespace|print|readonly|require(?:_once)?|return|switch|throw|trait|try|use|while)\b|[A-Za-z_]\w*\s*(?:\(|::))/;
@@ -81,31 +57,22 @@ function initial(): TypingContext {
     return { mode: 'code', escaped: false, inClass: false, expression: true, word: '' };
 }
 
-function rulesOf(language: string): Rules {
-    return {
-        script: isScript(language),
-        php: isPhp(language),
-        hash: hasHashComments(language),
-        hashAtWordStart: hashNeedsWordStart(language),
-        dash: hasDashComments(language),
-        slash: hasSlashComments(language),
-        block: hasBlockComments(language),
-        markup: hasMarkupComments(language)
-    };
-}
-
 function scanComment(state: TypingContext, text: string, at: number, end: number): number {
     const close = state.mode === 'block-comment' ? '*/' : '-->';
+
     if (at + close.length <= end && text.startsWith(close, at)) {
         state.mode = 'code';
         state.commentStart = undefined;
+
         return at + close.length - 1;
     }
+
     return at;
 }
 
 function scanLiteral(state: TypingContext, text: string, at: number, end: number, offset: number): number {
     const char = text[at];
+
     if (state.escaped) {
         state.escaped = false;
     } else if (char === '\\') {
@@ -124,18 +91,21 @@ function scanLiteral(state: TypingContext, text: string, at: number, end: number
         state.mode = 'code';
         state.expression = true;
         state.word = '';
+
         return at + 1;
     } else if (char === state.quote) {
         state.mode = 'code';
         state.expression = false;
         state.quote = undefined;
     }
+
     return at;
 }
 
 function openComment(state: TypingContext, mode: 'line-comment' | 'block-comment' | 'html-comment', start: number, resume: number): number {
     state.mode = mode;
     state.commentStart = start;
+
     return resume;
 }
 
@@ -146,48 +116,64 @@ function scanCode(state: TypingContext, rules: Rules, text: string, at: number,
     if (/\s/u.test(char)) {
         return at;
     }
+
     if (rules.markup && text.startsWith('<!--', at)) {
         return openComment(state, 'html-comment', offset + at, at + 3);
     }
+
     if (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at))) {
         return openComment(state, 'line-comment', offset + at, at);
     }
+
     if ((rules.dash && char === '-' && next === '-') || (rules.slash && char === '/' && next === '/')) {
         return openComment(state, 'line-comment', offset + at, at + 1);
     }
+
     if (rules.block && char === '/' && next === '*') {
         return openComment(state, 'block-comment', offset + at, at + 1);
     }
+
     if (rules.php && char === '<' && text.startsWith('<<<', at)) {
         const opener = PHP_HEREDOC.exec(text.slice(at));
+
         if (opener !== null) {
             state.mode = 'heredoc';
             state.quote = opener[2];
+
             return text.length;
         }
     }
+
     if (rules.php && char === '?' && next === '>') {
         state.phpClose = offset + at + 2;
         state.mode = 'html';
+
         return at + 1;
     }
+
     if (char === '"' || char === "'" || char === '`') {
         state.mode = rules.script && char === '`' ? 'template' : 'quote';
         state.quote = char;
         state.escaped = false;
         state.word = '';
+
         return at;
     }
+
     if (rules.script && char === '/' && state.expression) {
         state.mode = 'regex';
         state.inClass = false;
         state.escaped = false;
+
         return at;
     }
+
     if ((char === '+' || char === '-') && next === char) {
         state.word = '';
+
         return at + 1;
     }
+
     if (openers[char]) {
         state.bracket = {
             at: offset + at,
@@ -196,15 +182,18 @@ function scanCode(state: TypingContext, rules: Rules, text: string, at: number,
             control: char === '(' && controlWords.test(state.word),
             block: char === '{' && (!state.expression || state.word === 'control-close' || blockWords.test(state.word))
         };
+
         state.expression = true;
         state.word = '';
     } else if (/[)\]}]/.test(char)) {
         closeBracket(state, char);
     } else if (isWordCharacter(char)) {
         const from = at;
+
         while (at + 1 < end && isWordCharacter(text[at + 1])) {
             at++;
         }
+
         const word = text.slice(from, at + 1);
         state.word = word === 'await' && state.word === 'for' ? 'for-await' : word;
         state.expression = startsExpression(word);
@@ -212,21 +201,27 @@ function scanCode(state: TypingContext, rules: Rules, text: string, at: number,
         state.expression = startsExpressionAfter(char);
         state.word = '';
     }
+
     return at;
 }
 
 function closeBracket(state: TypingContext, char: string): void {
     const bracket = state.bracket;
+
     if (bracket?.close !== char) {
         state.bracket = undefined;
         state.expression = false;
+
         return;
     }
+
     state.bracket = bracket.previous;
+
     if (bracket.template) {
         state.mode = 'template';
         state.quote = '`';
     }
+
     state.expression = Boolean(bracket.control || bracket.block);
     state.word = bracket.control ? 'control-close' : '';
 }
@@ -237,10 +232,14 @@ function stepScript(state: TypingContext, text: string, at: number, end: number,
     if (state.mode === 'line-comment') {
         return at;
     }
+
     if (state.mode === 'block-comment') {
         return scanComment(state, text, at, end);
     }
-    return state.mode === 'code' ? scanCode(state, (scriptRules ??= rulesOf('javascript')), text, at, end, offset) : scanLiteral(state, text, at, end, offset);
+
+    return state.mode === 'code'
+        ? scanCode(state, (scriptRules ??= lexerRules('javascript')), text, at, end, offset)
+        : scanLiteral(state, text, at, end, offset);
 }
 
 const scriptLexer = { initial, step: stepScript };
@@ -252,6 +251,7 @@ function normalizeLine(state: TypingContext, multilineQuotes: boolean): void {
         state.commentStart = undefined;
         state.expression = true;
     }
+
     state.escaped = false;
 }
 
@@ -259,13 +259,16 @@ function normalizeLine(state: TypingContext, multilineQuotes: boolean): void {
 function scan(text: string, end: number, start: TypingContext, rules: Rules, offset: number): TypingContext {
     // An embedded lexer must not mutate the script state cached at the line start.
     const state = { ...start, embed: start.embed === undefined ? undefined : { ...start.embed } };
+
     for (let at = 0; at < end; at++) {
         if (state.mode === 'line-comment') {
             // A PHP line comment ends at its line break and at a closing tag.
             const tag = rules.php ? text.indexOf('?>', at) : -1;
+
             if (tag < 0 || tag >= end) {
                 break;
             }
+
             state.phpClose = offset + tag + 2;
             state.mode = 'html';
             state.commentStart = undefined;
@@ -274,9 +277,11 @@ function scan(text: string, end: number, start: TypingContext, rules: Rules, off
             at = scanPhpMarkup(state, text, at, end, offset, scriptLexer);
         } else if (state.mode === 'heredoc') {
             const closing = new RegExp(`^[\\t ]*${state.quote}(?![\\w])`).exec(text);
+
             if (closing === null) {
                 break;
             }
+
             state.mode = 'code';
             state.quote = undefined;
             state.expression = false;
@@ -289,6 +294,7 @@ function scan(text: string, end: number, start: TypingContext, rules: Rules, off
             at = scanLiteral(state, text, at, end, offset);
         }
     }
+
     return state;
 }
 
@@ -324,6 +330,7 @@ export class TypingContexts {
 
     invalidate(line = 0): void {
         this.states.length = Math.min(this.states.length, Math.max(1, line + 1));
+
         if (line <= this.decidingLine) {
             this.language = '';
         }
@@ -332,54 +339,71 @@ export class TypingContexts {
     private initialState(language: string): TypingContext {
         const state = initial();
         this.decidingLine = 0;
+
         if (language !== 'php') {
             return state;
         }
+
         let remaining = PHP_INITIAL_CHARACTERS;
+
         for (let line = 0; line < PHP_INITIAL_LINES && remaining > 0; line++) {
             this.decidingLine = line;
             const source = this.line(line);
             const sample = source.text.slice(0, remaining);
             remaining -= sample.length;
             const text = sample.trimStart();
+
             if (text !== '') {
                 const open = PHP_OPEN.exec(text);
+
                 if (/^<(?![?<])/.test(text) || (open !== null && open.index > 0 && !PHP_FRAGMENT_START.test(text))) {
                     state.mode = 'html';
                 }
+
                 return state;
             }
+
             if (source.end === source.next) {
                 break;
             }
         }
+
         return state;
     }
 
     at(line: number, column: number, language: string): TypingContext {
         const id = language.toLowerCase();
+
         if (this.language !== id) {
             this.language = id;
             this.states = [this.initialState(id)];
         }
-        const rules = rulesOf(id);
+
+        const rules = lexerRules(id);
+
         while (this.states.length <= line) {
             const previous = this.states.at(-1)!;
             const source = this.line(this.states.length - 1);
             const next = scan(source.text, source.text.length, previous, rules, source.start);
+
             // A PHP island's source newlines are not newlines in the emitted script.
             if (next.mode === 'html' && next.embed !== undefined && next.phpClose !== source.end) {
                 normalizeLine(next.embed, false);
             }
+
             next.phpClose = undefined;
             normalizeLine(next, /^(php|rust|rs)$/i.test(id));
+
             if (next.mode === 'html' && next.markup === 'value' && next.markupQuote === undefined) {
                 next.markup = 'tag';
             }
+
             this.states.push(sameState(next, previous) ? previous : next);
         }
+
         const source = this.line(line);
         const state = scan(source.text, column, this.states[line], rules, source.start);
+
         return state.mode === 'html' && state.embed !== undefined ? { ...state.embed, markup: 'raw', element: 'script', embedded: 'javascript' } : state;
     }
 }

package/src/typing-handlers.ts

@@ -18,12 +18,15 @@ export function isQuote(character: string): boolean {
 function quotesIn(body: string, selected: string, typed: string): { index: number; escaped: boolean }[] {
     const found: { index: number; escaped: boolean }[] = [];
     let escaped = false;
+
     for (let index = 0; index < body.length; index++) {
         const character = body[index]!;
+
         if (escaped) {
             if (character === selected || character === typed) {
                 found.push({ index, escaped: true });
             }
+
             escaped = false;
         } else if (character === '\\') {
             escaped = true;
@@ -31,6 +34,7 @@ function quotesIn(body: string, selected: string, typed: string): { index: numbe
             found.push({ index, escaped: false });
         }
     }
+
     return found;
 }
 
@@ -39,9 +43,12 @@ function stringAround(source: EditSource, offset: number, quote: string): { star
     const line = source.line(source.lineAt(offset));
     const before = source.context(offset);
     const after = source.context(offset + 1);
+
     const inString = (mode: string): boolean => mode === 'quote' || mode === 'template';
+
     if (before.mode === 'code' && inString(after.mode) && after.quote === quote) {
         const text = source.slice(offset + 1, line.end);
+
         for (let at = 0; at < text.length; at++) {
             if (text[at] === '\\') {
                 at++;
@@ -49,20 +56,26 @@ function stringAround(source: EditSource, offset: number, quote: string): { star
                 return { start: offset, end: offset + 1 + at };
             }
         }
+
         return null;
     }
+
     if (inString(before.mode) && before.quote === quote && !before.escaped && after.mode === 'code') {
         const text = source.slice(line.start, offset);
+
         for (let at = text.length - 1; at >= 0; at--) {
             let slashes = 0;
+
             while (at - slashes - 1 >= 0 && text[at - slashes - 1] === '\\') {
                 slashes++;
             }
+
             if (text[at] === quote && slashes % 2 === 0) {
                 return { start: line.start + at, end: offset };
             }
         }
     }
+
     return null;
 }
 
@@ -72,24 +85,33 @@ function stringAround(source: EditSource, offset: number, quote: string): { star
  */
 export function swapQuotes(source: EditSource, offset: number, typed: string): HandlerEdit | null {
     const selected = source.charAt(offset);
+
     if (selected === typed || !isQuote(selected) || !isQuote(typed)) {
         return null;
     }
+
     const span = stringAround(source, offset, selected);
+
     if (!span) {
         return null;
     }
+
     const body = source.slice(span.start + 1, span.end);
     const inside = quotesIn(body, selected, typed);
     const interpolated = selected === '`' && body.includes('${');
+
     if (interpolated && inside.length > 0) {
         return null;
     }
+
     let rewritten = body;
+
     if (!interpolated) {
         let shift = 0;
+
         for (const { index, escaped } of inside) {
             const character = body[index]!;
+
             if (character === typed && !escaped) {
                 rewritten = rewritten.slice(0, index + shift) + '\\' + rewritten.slice(index + shift);
                 shift++;
@@ -99,7 +121,9 @@ export function swapQuotes(source: EditSource, offset: number, typed: string): H
             }
         }
     }
+
     const text = typed + rewritten + typed;
+
     return { from: span.start, to: span.end + 1, text, caret: offset === span.start ? 1 : text.length };
 }
 
@@ -118,6 +142,7 @@ export function matchingDelimiter(character: string): string {
 
 function similarDelimiters(left: string, right: string): boolean {
     const bracket = (character: string): boolean => /[([{<]/.test(character);
+
     return (bracket(left) && bracket(right)) || (isQuote(left) && isQuote(right));
 }
 
@@ -127,9 +152,11 @@ function similarDelimiters(left: string, right: string): boolean {
  */
 export function surround(selected: string, typed: string): { text: string; inner: string } {
     let inner = selected;
+
     if (selected.length > 1) {
         const first = selected[0]!;
         const last = selected.at(-1)!;
+
         if (
             similarDelimiters(first, typed) &&
             last === matchingDelimiter(first) &&
@@ -139,5 +166,6 @@ export function surround(selected: string, typed: string): { text: string; inner
             inner = selected.slice(1, -1);
         }
     }
+
     return { text: typed + inner + matchingDelimiter(typed), inner };
 }

package/src/words.ts

@@ -35,11 +35,13 @@ export function isHumpBoundary(text: WordText, offset: number, isStart: boolean)
     if (offset <= 0 || offset >= text.length) {
         return false;
     }
+
     const previous = characterAt(text, offset - 1);
     const current = characterAt(text, offset);
     const next = characterAt(text, offset + 1);
     const hump = isStart ? current : previous;
     const neighbor = isStart ? previous : current;
+
     return (
         ((lower.test(previous) || digit.test(previous)) && upper.test(current)) ||
         (neighbor === '_' && hump !== '_') ||
@@ -53,30 +55,38 @@ export function isWordBoundary(text: WordText, offset: number, camel: boolean, i
     if (offset < 0 || offset > text.length) {
         return false;
     }
+
     const previous = characterAt(text, offset - 1);
     const current = characterAt(text, offset);
     const word = isStart ? current : previous;
     const neighbor = isStart ? previous : current;
+
     if (identifierPart.test(word)) {
         if (!identifierPart.test(neighbor)) {
             return true;
         }
+
         if (camel && isHumpBoundary(text, offset, isStart)) {
             return true;
         }
     }
+
     return isPunctuation(word) && !isPunctuation(neighbor);
 }
 
 /* The next stop in `direction`, never inside a surrogate pair or between CR and LF. Written here, not ported. */
 export function wordBoundary(text: WordText, offset: number, direction: -1 | 1, camel = true): number {
     let position = offset + direction;
+
     while (position > 0 && position < text.length) {
         const splitsLineBreak = text.charAt(position - 1) === '\r' && text.charAt(position) === '\n';
+
         if (!splitsSurrogate(text, position) && !splitsLineBreak && isWordBoundary(text, position, camel, direction === -1)) {
             return position;
         }
+
         position += direction;
     }
+
     return Math.max(0, Math.min(text.length, position));
 }