@adecore/editor-core 0.22.1 → 0.23.1

package/dist/types.d.ts

@@ -34,11 +34,14 @@ export interface EditorSnapshot {
     changes?: readonly (readonly DocumentChange[])[];
     contentEdits?: readonly ContentEdit[];
     source?: ChangeSource;
+    typed?: boolean;
 }
 export interface EditOptions {
     selections?: readonly Selection[];
     source?: ChangeSource;
     historyGroup?: string;
+    joinPrevious?: boolean;
+    typed?: boolean;
 }
 export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine';
 export interface CommandOptions {

package/dist/typing-context.d.ts

@@ -17,11 +17,19 @@ export interface TypingContext {
     expression: boolean;
     word: string;
     commentStart?: number;
+    markup?: 'tag' | 'equals' | 'value' | 'comment' | 'raw';
+    markupQuote?: '"' | "'";
+    element?: 'script' | 'style' | 'textarea' | 'title';
+    embed?: TypingContext;
+    embedded?: 'javascript';
+    embedStart?: number;
+    phpClose?: number;
 }
 export declare class TypingContexts {
     private readonly line;
     private states;
     private language;
+    private decidingLine;
     constructor(line: (index: number) => DocumentLine);
     invalidate(line?: number): void;
     private initialState;

package/dist/typing-context.js

@@ -1,6 +1,11 @@
 import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.js';
+import { scanPhpMarkup } from './php-markup.js';
 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*(?:\(|::))/;
 const controlWords = /^(for|for-await|if|while|switch|catch|with)$/;
 const blockWords = /^(else|try|finally|do)$/;
 function initial() {
@@ -93,6 +98,7 @@ function scanCode(state, rules, text, at, end, offset) {
         }
     }
     if (rules.php && char === '?' && next === '>') {
+        state.phpClose = offset + at + 2;
         state.mode = 'html';
         return at + 1;
     }
@@ -157,9 +163,30 @@ function closeBracket(state, char) {
     state.expression = Boolean(bracket.control || bracket.block);
     state.word = bracket.control ? 'control-close' : '';
 }
+let scriptRules;
+function stepScript(state, text, at, end, offset) {
+    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);
+}
+const scriptLexer = { initial, step: stepScript };
+function normalizeLine(state, multilineQuotes) {
+    if (state.mode === 'line-comment' || state.mode === 'regex' || (state.mode === 'quote' && !multilineQuotes && !state.escaped)) {
+        state.mode = 'code';
+        state.quote = undefined;
+        state.commentStart = undefined;
+        state.expression = true;
+    }
+    state.escaped = false;
+}
 /* Lexes `text` up to `end`, from the state the line started in. `offset` is where the line starts in the document. */
 function scan(text, end, start, rules, offset) {
-    const state = { ...start };
+    // 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.
@@ -167,19 +194,13 @@ function scan(text, end, start, rules, offset) {
             if (tag < 0 || tag >= end) {
                 break;
             }
+            state.phpClose = offset + tag + 2;
             state.mode = 'html';
             state.commentStart = undefined;
             at = tag + 1;
         }
         else if (state.mode === 'html') {
-            const open = PHP_OPEN.exec(text.slice(at));
-            if (open === null || at + open.index >= end) {
-                break;
-            }
-            state.mode = 'code';
-            state.expression = true;
-            state.word = '';
-            at += open.index + open[0].length - 1;
+            at = scanPhpMarkup(state, text, at, end, offset, scriptLexer);
         }
         else if (state.mode === 'heredoc') {
             const closing = new RegExp(`^[\\t ]*${state.quote}(?![\\w])`).exec(text);
@@ -211,27 +232,52 @@ function sameState(left, right) {
         left.bracket === right.bracket &&
         left.expression === right.expression &&
         left.word === right.word &&
-        left.commentStart === right.commentStart);
+        left.commentStart === right.commentStart &&
+        left.markup === right.markup &&
+        left.markupQuote === right.markupQuote &&
+        left.element === right.element &&
+        left.phpClose === right.phpClose &&
+        left.embedStart === right.embedStart &&
+        (left.embed === right.embed || (left.embed !== undefined && right.embed !== undefined && sameState(left.embed, right.embed))));
 }
 /* The state of the lexer at the start of each line, computed on demand. An edit drops the lines from its own on. */
 export class TypingContexts {
     line;
     states = [initial()];
     language = '';
+    decidingLine = 0;
     constructor(line) {
         this.line = line;
     }
     invalidate(line = 0) {
         this.states.length = Math.min(this.states.length, Math.max(1, line + 1));
-        if (line === 0) {
+        if (line <= this.decidingLine) {
             this.language = '';
         }
     }
-    /* A PHP file that opens with markup, and not with a tag, starts outside the PHP. */
     initialState(language) {
         const state = initial();
-        if (language === 'php' && /^\s*<(?![?<])/.test(this.line(0).text)) {
-            state.mode = 'html';
+        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;
     }
@@ -246,17 +292,19 @@ export class TypingContexts {
             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);
-            // Only PHP and Rust strings run past a line break without a trailing backslash.
-            if (next.mode === 'line-comment' || next.mode === 'regex' || (next.mode === 'quote' && !/^(php|rust|rs)$/i.test(id) && !next.escaped)) {
-                next.mode = 'code';
-                next.quote = undefined;
-                next.commentStart = undefined;
-                next.expression = true;
+            // 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';
             }
-            next.escaped = false;
             this.states.push(sameState(next, previous) ? previous : next);
         }
         const source = this.line(line);
-        return scan(source.text, column, this.states[line], rules, source.start);
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "type": "module",
   "exports": {
     ".": {

package/src/comments.ts

@@ -1,4 +1,6 @@
 import type { EditPlan, EditSource } from './edit-source.ts';
+import { editRegions, phpLiteralAt, phpTagAt, type EditRegions } from './edit-regions.ts';
+import { hasJsx } from './markup-regions.ts';
 import { type BlockComment, type CommentSyntax, commentSyntax } from './languages.ts';
 import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.ts';
 import { mapOffset } from './offsets.ts';
@@ -27,8 +29,8 @@ interface Geometry {
     length: number;
 }
 
-function syntaxOf(source: EditSource, options: CommentOptions, line: number): CommentSyntax {
-    const syntax = commentSyntax(options.language, source.region(line));
+function syntaxOf(regions: EditRegions, options: CommentOptions, line: number, offset?: number): CommentSyntax {
+    const syntax = commentSyntax(options.language, regions(line, offset));
     return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
 }
 
@@ -89,19 +91,42 @@ function geometryOf(source: EditSource, edits: readonly TextEdit[], index: numbe
  * The markers go in at the smallest indentation of the lines, and a lone caret moves to the next line.
  */
 export function planLineComments(source: EditSource, selections: readonly Selection[], options: CommentOptions): EditPlan | null {
+    const regions = editRegions(source, options.language);
     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 = new Map<number, CommentSyntax>();
+    for (const block of blocks) {
+        let marker: CommentSyntax | undefined;
+        let mixed = false;
+        const firstSyntax = hasJsx(options.language) && block.first !== block.last ? syntaxOf(regions, options, block.first) : undefined;
+        for (let line = block.first; line <= block.last; line++) {
+            const syntax = firstSyntax ?? syntaxOf(regions, options, line);
+            const effective = syntax.line === null ? syntax : { ...syntax, block: null };
+            lineBased.set(line, effective);
+            if (effective.line !== null || effective.block !== null) {
+                mixed ||=
+                    marker !== undefined &&
+                    (marker.line !== effective.line || marker.block?.open !== effective.block?.open || marker.block?.close !== effective.block?.close);
+                marker ??= effective;
+            }
+        }
+        // Commenting a region opener would change the markers needed for the next toggle.
+        if (mixed && /^(php|vue)$/i.test(options.language)) {
+            for (let line = block.first; line <= block.last; line++) {
+                lineBased.set(line, { line: null, block: null });
+            }
+        }
     }
-    const lineBased = syntaxes.map((syntax): CommentSyntax => (syntax.line === null ? syntax : { ...syntax, block: null }));
     let allCommented = true;
     let anyCommented = false;
-    for (const [position, block] of blocks.entries()) {
+    for (const block of blocks) {
         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);
+            const syntax = lineBased.get(line)!;
+            if (syntax.line === null && syntax.block === null) {
+                continue;
+            }
+            const commented = isCommented(text, syntax, !single);
             if (commented && !isBlank(text)) {
                 anyCommented = true;
             }
@@ -116,8 +141,8 @@ export function planLineComments(source: EditSource, selections: readonly Select
 
     const edits: TextEdit[] = [];
     const placed = new Set<number>();
-    for (const [position, block] of blocks.entries()) {
-        const syntax = lineBased[position]!;
+    for (const block of blocks) {
+        const syntax = lineBased.get(block.first)!;
         const multiline = block.first !== block.last;
         const startingNewLine =
             !multiline &&
@@ -127,6 +152,10 @@ export function planLineComments(source: EditSource, selections: readonly Select
         const minimum = allCommented ? 0 : minimumIndent(source, block, syntax, options);
         for (let line = block.first; line <= block.last; line++) {
             const bounds = source.line(line);
+            const syntax = lineBased.get(line)!;
+            if (syntax.line === null && syntax.block === null) {
+                continue;
+            }
             const edit = allCommented
                 ? uncommentLine(bounds.start, bounds.text, syntax)
                 : commentLine(bounds.start, bounds.text, syntax, minimum, multiline, startingNewLine, options);
@@ -239,7 +268,7 @@ function finalSelections(
     edits: readonly TextEdit[],
     allCommented: boolean,
     placed: ReadonlySet<number>,
-    syntaxes: readonly CommentSyntax[],
+    syntaxes: ReadonlyMap<number, CommentSyntax>,
     span: CommentOptions['lineSpan']
 ): Selection[] {
     const sorted = [...edits].sort((left, right) => left.from - right.from);
@@ -251,13 +280,17 @@ function finalSelections(
     if (!moveCarets) {
         return result;
     }
-    for (const [position, block] of blocks.entries()) {
+    for (const block of blocks) {
         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]!);
+                const syntax = syntaxes.get(line)!;
+                if (syntax.line === null && syntax.block === null) {
+                    continue;
+                }
+                result[index] = caretAfter(source, sorted, line, span?.(line).last ?? line, selection.head, allCommented, placed, syntax);
                 continue;
             }
             const lastLine = source.lineAt(to - 1);
@@ -302,7 +335,7 @@ function commentAround(source: EditSource, offset: number, block: BlockComment):
     if ((context.mode !== 'block-comment' && context.mode !== 'html-comment') || context.commentStart === undefined) {
         return null;
     }
-    const from = context.commentStart;
+    const from = block.open === '{/*' && source.charAt(context.commentStart - 1) === '{' ? context.commentStart - 1 : context.commentStart;
     if (source.slice(from, from + block.open.length) !== block.open) {
         return null;
     }
@@ -327,12 +360,34 @@ function commentOf(source: EditSource, from: number, to: number, block: BlockCom
  * With nothing selected it opens an empty comment around the caret.
  */
 export function planBlockComment(source: EditSource, selections: readonly Selection[], options: CommentOptions): EditPlan | null {
+    const regions = editRegions(source, options.language);
     const edits: TextEdit[] = [];
     const result: Selection[] = [];
     let offsetDelta = 0;
     for (const selection of selections) {
         const { from, to } = rangeOf(selection);
-        const block = syntaxOf(source, options, source.lineAt(from)).block;
+        if (/^php$/i.test(options.language)) {
+            const context = source.context(from);
+            const { mode } = context;
+            const endContext = source.context(to);
+            const endMode = endContext.mode;
+            const endsLineComment = mode === 'code' && endMode === 'line-comment' && source.slice(to, source.line(source.lineAt(to)).end).trim() === '';
+            const text = source.slice(from, to);
+            // Wrapping a PHP tag can move a closing marker into a different language.
+            if (
+                phpLiteralAt(source, from) ||
+                phpLiteralAt(source, to) ||
+                phpTagAt(source, from) ||
+                phpTagAt(source, to) ||
+                (mode !== endMode && !endsLineComment) ||
+                context.embedStart !== endContext.embedStart ||
+                /<\?(?:php\b|=)/.test(text) ||
+                (mode !== 'html' && context.embedded === undefined && text.includes('?>'))
+            ) {
+                return null;
+            }
+        }
+        const block = syntaxOf(regions, options, source.lineAt(from), from).block;
         if (!block) {
             return null;
         }

package/src/doc-comments.ts

@@ -0,0 +1,104 @@
+import { commentRole } from './fold-roles.ts';
+import { commentSyntax, vueRegionAt } from './languages.ts';
+import { scanStructure } from './structure.ts';
+
+/* A documentation comment that stands on lines of its own, so a row can take its place. */
+export interface DocComment {
+    /* Offsets of its opener and of the end of its closer. */
+    from: number;
+    to: number;
+    /* Zero-based and inclusive. */
+    startLine: number;
+    endLine: number;
+    /* The whitespace in front of the comment on its first line. */
+    indent: string;
+    /* The text between the delimiters with the margin stars taken off. */
+    body: string;
+}
+
+/* Past this many comments in one document the rest are left as text. */
+export const MAX_DOC_COMMENTS = 500;
+
+function bodyOf(inner: string): string {
+    const lines = inner.split(/\r\n|\r|\n/).map((line, index) => (index === 0 ? line.replace(/^[ \t]+/, '') : line.replace(/^[ \t]*\*?[ \t]?/, '')));
+    const last = lines.length - 1;
+    lines[last] = lines[last]!.replace(/[ \t*]+$/, '');
+    while (lines.length > 0 && lines[0]!.trim() === '') {
+        lines.shift();
+    }
+    while (lines.length > 0 && lines.at(-1)!.trim() === '') {
+        lines.pop();
+    }
+    return lines.map((line) => line.replace(/[ \t]+$/, '')).join('\n');
+}
+
+const HEREDOC_OPENER = /<<<[ \t]*(?:'(\w+)'|"(\w+)"|(\w+))\r?\n/g;
+
+/* The bodies of PHP heredocs and nowdocs, which the structure scan reads as code. Offsets of the first character after the opener and of the closing label. */
+function heredocBodies(text: string): [number, number][] {
+    const result: [number, number][] = [];
+    for (const opener of text.matchAll(HEREDOC_OPENER)) {
+        const label = opener[1] ?? opener[2] ?? opener[3]!;
+        const from = opener.index + opener[0].length;
+        const closer = new RegExp(`^[ \\t]*${label}\\b`, 'm').exec(text.slice(from));
+        result.push([from, closer === null ? text.length : from + closer.index]);
+    }
+    return result;
+}
+
+/*
+ * The block comments that open with two stars and have their lines to themselves: nothing but
+ * whitespace before the opener and after the closer. Only languages that write block comments as
+ * a slash and a star have any, and a Vue file has them in its script. A comment that shares a line
+ * with code is left out, since a row could not take its lines without hiding the code. A banner of
+ * three stars or more is no documentation, and nor is the text of a PHP heredoc or nowdoc. A heredoc
+ * body is still read as code by the scan, so a quote in it can hide the comments that follow.
+ */
+export function findDocComments(text: string, language: string, limit = MAX_DOC_COMMENTS): DocComment[] {
+    const vue = language.toLowerCase() === 'vue';
+    const syntax = commentSyntax(language, vue ? 'script' : null);
+    if (syntax.block?.open !== '/*' || syntax.line !== '//' || !text.includes('/**')) {
+        return [];
+    }
+    const result: DocComment[] = [];
+    const bodies = language.toLowerCase() === 'php' && text.includes('<<<') ? heredocBodies(text) : [];
+    const lines = vue ? text.split(/\r\n|\r|\n/) : null;
+    let counted = 0;
+    let line = 0;
+    for (const range of scanStructure(text)) {
+        if (result.length >= limit) {
+            break;
+        }
+        if (range.kind !== 'comment' || commentRole((from, to) => text.slice(from, to), range.from, range.to) === undefined) {
+            continue;
+        }
+        // Three stars or more is a banner, not a comment about the code under it.
+        if (text[range.from + 3] === '*' || bodies.some(([from, to]) => range.from >= from && range.from < to)) {
+            continue;
+        }
+        const lineStart = Math.max(text.lastIndexOf('\n', range.from - 1), text.lastIndexOf('\r', range.from - 1)) + 1;
+        const newline = text.slice(range.to).search(/[\r\n]/);
+        const lineEnd = newline === -1 ? text.length : range.to + newline;
+        const before = text.slice(lineStart, range.from);
+        if (!/^[ \t]*$/.test(before) || !/^[ \t]*$/.test(text.slice(range.to, lineEnd))) {
+            continue;
+        }
+        for (; counted < range.from; counted++) {
+            if (text[counted] === '\n' || (text[counted] === '\r' && text[counted + 1] !== '\n')) {
+                line++;
+            }
+        }
+        const startLine = line;
+        if (lines !== null && vueRegionAt((index) => lines[index] ?? '', startLine) !== 'script') {
+            continue;
+        }
+        let endLine = startLine;
+        for (let at = range.from; at < range.to; at++) {
+            if (text[at] === '\n' || (text[at] === '\r' && text[at + 1] !== '\n')) {
+                endLine++;
+            }
+        }
+        result.push({ from: range.from, to: range.to, startLine, endLine, indent: before, body: bodyOf(text.slice(range.innerFrom + 1, range.innerTo)) });
+    }
+    return result;
+}