@adecore/editor-core 0.39.0 → 0.40.1

package/src/fold-roles.ts

@@ -1,5 +1,5 @@
-import { isImportLine, rangeOf, textStart } from './lexical-folds.ts';
-import { isBlank } from './line-text.ts';
+import { isImportLine, rangeOf } from './lexical-folds.ts';
+import { isBlank, textStart } from './line-text.ts';
 import type { DocumentLine } from './rope.ts';
 import type { FoldHints, FoldRangeHint, FoldRole, FoldingRange } from './structure.ts';
 
@@ -23,26 +23,34 @@ export function commentRole(slice: (from: number, to: number) => string, from: n
 export function bracketRole(slice: (from: number, to: number) => string, from: number, language: string): FoldRole | undefined {
     const opener = slice(from, from + 1);
     const before = slice(Math.max(0, from - LOOK_BEHIND), from);
+
     if (language.toLowerCase() === 'php') {
         return opener === '[' && before.endsWith('#') ? 'attribute' : undefined;
     }
+
     if (!SCRIPT_LANGUAGES.test(language) || (opener !== '{' && opener !== '[')) {
         return undefined;
     }
+
     const head = before.slice(before.lastIndexOf('\n') + 1);
     const trimmed = before.trimEnd();
     const previous = trimmed.at(-1);
+
     if (previous === undefined) {
         return undefined;
     }
+
     const arrow = trimmed.endsWith('=>');
     const value = (/[=:(,[?]/.test(previous) && !arrow) || VALUE_WORDS.test(trimmed) || (arrow && opener === '[');
+
     if (!value) {
         return undefined;
     }
+
     if (opener === '[') {
         return 'array-literal';
     }
+
     // A `case x: {` and a `type A = {` are a block and a type, not a value.
     return /^\s*(?:case\b|default\s*:|(?:export\s+)?(?:declare\s+)?(?:type|interface)\b)/.test(head) ? undefined : 'object-literal';
 }
@@ -53,20 +61,26 @@ export function bracketRole(slice: (from: number, to: number) => string, from: n
  */
 export function markFileHeader(ranges: FoldingRange[], getLine: (line: number) => DocumentLine, lineCount: number, language: string): void {
     const candidate = ranges.find((range) => (range.kind === 'comment' || range.kind === 'line-comments') && range.startLine <= HEADER_LINES);
+
     if (candidate === undefined) {
         return;
     }
+
     for (let line = 0; line < candidate.startLine; line++) {
         const text = getLine(line).text;
+
         if (!isBlank(text) && !(line === 0 && /^(#!|<\?php\s*$)/.test(text))) {
             return;
         }
     }
+
     if (candidate.from > textStart(getLine(candidate.startLine))) {
         return;
     }
+
     const next = candidate.endLine + 1 < lineCount ? getLine(candidate.endLine + 1).text : '';
     const attached = candidate.role === 'doc-comment' && !isBlank(next) && !isImportLine(language, next.trimStart());
+
     if (!attached) {
         candidate.role = 'file-header';
     }
@@ -77,12 +91,15 @@ function serverRole(kind: string | undefined, text: string): FoldRole | undefine
     if (kind === 'imports') {
         return 'imports';
     }
+
     if (kind === 'region') {
         return 'region';
     }
+
     if (kind === 'comment') {
         return text.startsWith('/**') ? 'doc-comment' : undefined;
     }
+
     return text.startsWith('<') ? 'tag' : undefined;
 }
 
@@ -100,31 +117,40 @@ export function applyFoldHints(
     minimum: number
 ): FoldingRange[] {
     const result = ranges.map((range) => ({ ...range }));
+
     for (const symbol of hints.symbols ?? []) {
         const startLine = lineAt(symbol.from);
         const endLine = lineAt(Math.max(symbol.from, symbol.to - 1));
         const body = bodyOf(result, symbol, startLine, endLine, slice);
+
         if (body !== undefined) {
             body.range.role = body.role;
         }
     }
+
     const starts = new Set(result.map((range) => range.startLine));
+
     for (const hint of hints.ranges ?? []) {
         const startLine = lineAt(hint.from);
         const endLine = lineAt(hint.to);
         const same = result.find((range) => range.startLine === startLine && range.endLine === endLine);
+
         // The text's own fold of the same lines keeps its kind and role, and takes where the server hides from and shows again from.
         if (same !== undefined) {
             Object.assign(same, edgesOf(hint));
+
             continue;
         }
+
         if (endLine - startLine < minimum || starts.has(startLine)) {
             continue;
         }
+
         starts.add(startLine);
         const role = serverRole(hint.kind, getLine(startLine).text.trimStart());
         result.push({ ...rangeOf(startLine, endLine, getLine, 'server', role), ...edgesOf(hint) });
     }
+
     return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
 
@@ -144,20 +170,26 @@ function bodyOf(
         .filter((range) => range.kind === 'bracket' && range.from >= symbol.from && range.to <= symbol.to && slice(range.from, range.from + 1) === '{')
         .filter((range) => /^[\s;,]*$/.test(slice(range.to, symbol.to)))
         .sort((left, right) => right.to - left.to || left.from - right.from)[0];
+
     const range =
         brace ??
         ranges
             .filter((candidate) => candidate.kind === 'indentation' && candidate.endLine === endLine && candidate.startLine >= startLine)
             .sort((left, right) => left.startLine - right.startLine)[0];
+
     if (range === undefined) {
         return undefined;
     }
+
     if (symbol.body === 'class') {
         return { range, role: 'class-body' };
     }
+
     if (symbol.body === 'value') {
         const signature = slice(symbol.from, range.from);
+
         return /=>|\bfunction\b/.test(signature) ? { range, role: 'function-body' } : undefined;
     }
+
     return { range, role: symbol.body === 'method' ? 'method-body' : 'function-body' };
 }

package/src/index.ts

@@ -5,6 +5,7 @@ export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindM
 export { indentationColumn } from './structure.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from './doc-comments.ts';
 export type { FoldHints, FoldRangeHint, FoldRole, FoldSymbolHint, FoldingOptions, FoldingRange } from './structure.ts';
+
 export type {
     ChangeSource,
     CommandOptions,
@@ -18,4 +19,5 @@ export type {
     Selection,
     TextEdit
 } from './types.ts';
+
 export { changedSpan, changedSpans, type TextSpan } from './text-span.ts';

package/src/languages.ts

@@ -33,12 +33,15 @@ register(
     'typescript javascript typescriptreact javascriptreact tsx jsx ts js mjs cjs mts cts java c cpp c++ csharp cs go rust rs swift kotlin kt scala dart php scss less zig groq json jsonc json5 prisma astro svelte objective-c objc glsl hlsl proto protobuf hcl terraform',
     cLike
 );
+
 register('css', { line: null, block: slashStar });
 register('html xml svg xsl markdown md mdx vue', markup);
+
 register(
     'python py yaml yml shellscript shell sh bash zsh fish toml ruby rb perl r make makefile docker dockerfile dotenv ignore nix graphql powershell ps1 properties julia jl elixir ex exs coffeescript coffee cmake',
     hash
 );
+
 register('ini', { line: ';', block: null });
 register('sql', { line: '--', block: slashStar });
 register('lua', { line: '--', block: { open: '--[[', close: ']]' } });
@@ -48,18 +51,23 @@ register('plaintext text txt log', none);
 /* An id nothing knows has no comment syntax, which toggling a comment answers by doing nothing. */
 export function commentSyntax(language: string, region?: EditRegion | null): CommentSyntax {
     const id = language.toLowerCase();
+
     if (region === 'mixed') {
         return none;
     }
+
     if (region === 'jsx') {
         return { line: null, block: { open: '{/*', close: '*/}' } };
     }
+
     if (id === 'vue' || (id === 'php' && region !== null && region !== undefined)) {
         if (region === 'script') {
             return cLike;
         }
+
         return region === 'style' ? { line: null, block: slashStar } : markup;
     }
+
     return syntaxes.get(id) ?? none;
 }
 
@@ -71,14 +79,17 @@ export function isPlainText(language: string): boolean {
 /* The region of a `.vue` file a line is in, from the top-level tags above it. */
 export function vueRegionAt(lineText: (line: number) => string, line: number): VueRegion | null {
     let region: VueRegion | null = null;
+
     for (let index = 0; index <= line; index++) {
         const text = lineText(index);
         const open = /^<(template|script|style)\b/.exec(text);
+
         if (open) {
             region = open[1] as VueRegion;
         } else if (/^<\/(template|script|style)\s*>/.test(text) && index < line) {
             region = null;
         }
     }
+
     return region;
 }

package/src/lexical-folds.ts

@@ -1,4 +1,5 @@
 import { commentSyntax } from './languages.ts';
+import { textStart } from './line-text.ts';
 import type { FoldRole, FoldingRange } from './structure.ts';
 import type { DocumentLine } from './rope.ts';
 
@@ -8,6 +9,7 @@ const IMPORT_WORDS = new Map<string, RegExp>();
 function register(languages: string, words: string): void {
     // The word must stand alone, and `import(` and `import.meta` are expressions and not an import.
     const pattern = new RegExp(`^(?:${words})\\b(?![(.=,;:])`);
+
     for (const language of languages.split(' ')) {
         IMPORT_WORDS.set(language, pattern);
     }
@@ -17,6 +19,7 @@ register(
     'typescript javascript typescriptreact javascriptreact tsx jsx ts js mjs cjs mts cts vue svelte astro java kotlin scala groovy go swift dart haskell elm',
     'import'
 );
+
 register('python py', 'import|from');
 register('php rust rs perl', 'use');
 register('csharp cs', 'using');
@@ -38,6 +41,7 @@ export interface LexicalFoldOptions {
 
 function bracketDelta(text: string): number {
     let depth = 0;
+
     for (const character of text) {
         if (character === '{' || character === '(' || character === '[') {
             depth++;
@@ -45,12 +49,8 @@ function bracketDelta(text: string): number {
             depth--;
         }
     }
-    return depth;
-}
 
-/* The offset of the first character of a line that is not indentation. */
-export function textStart(line: DocumentLine): number {
-    return line.start + (line.text.length - line.text.trimStart().length);
+    return depth;
 }
 
 /* A fold of whole lines, from the end of the first to the end of the last. */
@@ -85,50 +85,64 @@ export function lexicalFolds(lineCount: number, getLine: (line: number) => Docum
     let importEnd = -1;
     let commentStart = -1;
     let commentEnd = -1;
+
     const flushImports = (): void => {
         if (importStart !== -1 && importEnd > importStart) {
             result.push(rangeOf(importStart, importEnd, getLine, 'imports', 'imports'));
         }
+
         importStart = -1;
     };
+
     const flushComments = (): void => {
         if (commentStart !== -1 && commentEnd > commentStart) {
             result.push(rangeOf(commentStart, commentEnd, getLine, 'line-comments'));
         }
+
         commentStart = -1;
     };
+
     for (let line = 0; line < lineCount; line++) {
         const text = getLine(line).text;
         const trimmed = text.trimStart();
         const isRegionMarker = options.regions !== false && (REGION_START.test(text) || REGION_END.test(text));
+
         if (isRegionMarker) {
             flushComments();
+
             if (REGION_START.test(text)) {
                 regions.push(line);
             } else {
                 const start = regions.pop();
+
                 if (start !== undefined && line > start) {
                     result.push(rangeOf(start, line, getLine, 'region', 'region'));
                 }
             }
+
             continue;
         }
+
         if (marker !== null && trimmed.startsWith(marker)) {
             commentStart = commentStart === -1 ? line : commentStart;
             commentEnd = line;
         } else {
             flushComments();
         }
+
         if (words === undefined) {
             continue;
         }
+
         if (words.test(trimmed)) {
             let last = line;
             let depth = bracketDelta(text);
+
             while (depth > 0 && last + 1 < lineCount) {
                 last++;
                 depth += bracketDelta(getLine(last).text);
             }
+
             importStart = importStart === -1 ? line : importStart;
             importEnd = last;
             line = last;
@@ -136,7 +150,9 @@ export function lexicalFolds(lineCount: number, getLine: (line: number) => Docum
             flushImports();
         }
     }
+
     flushComments();
     flushImports();
+
     return result;
 }

package/src/lexical.ts

@@ -17,7 +17,7 @@ export function startsWord(text: string, at: number): boolean {
  */
 interface LanguageRules {
     slash: boolean;
-    /* `any` is a comment wherever it stands, `boundary` only at the start of a word, as in shell and YAML. */
+    /* `any` is a comment wherever it stands, `boundary` only at the start of a word, which keeps `$#` and `${#list}` in shell code. */
     hash: false | 'any' | 'boundary';
     dash: boolean;
     block: boolean;
@@ -39,6 +39,7 @@ register(
     'typescript javascript typescriptreact javascriptreact tsx jsx ts js mjs cjs mts cts java c cpp c++ csharp cs go rust rs swift kotlin kt scala dart zig groq prisma astro svelte objective-c objc glsl hlsl proto protobuf scss less jsonc json5',
     { slash: true, block: true, braced: true }
 );
+
 register('php', { slash: true, hash: 'any', block: true, braced: true });
 register('vue', { slash: true, block: true, markup: true, braced: true });
 register('hcl terraform', { slash: true, hash: 'any', block: true, braced: true });
@@ -54,6 +55,33 @@ function rulesOf(language: string): LanguageRules {
     return languageRules.get(language.toLowerCase()) ?? NO_RULES;
 }
 
+/* What the bracket and typing lexers read of a language, looked up once per scan. */
+export interface LexerRules {
+    script: boolean;
+    php: boolean;
+    hash: boolean;
+    hashAtWordStart: boolean;
+    dash: boolean;
+    slash: boolean;
+    block: boolean;
+    markup: boolean;
+}
+
+export function lexerRules(language: string): LexerRules {
+    const rules = rulesOf(language);
+
+    return {
+        script: isScript(language),
+        php: isPhp(language),
+        hash: hasHashComments(language),
+        hashAtWordStart: rules.hash === 'boundary',
+        dash: rules.dash,
+        slash: rules.slash,
+        block: rules.block,
+        markup: rules.markup
+    };
+}
+
 export function isScript(language: string): boolean {
     return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|vue)$/i.test(language);
 }
@@ -66,28 +94,6 @@ export function hasHashComments(language: string): boolean {
     return rulesOf(language).hash !== false;
 }
 
-/* Whether a `#` only starts a comment at the start of a word, which keeps `$#` and `${#list}` in shell code. */
-export function hashNeedsWordStart(language: string): boolean {
-    return rulesOf(language).hash === 'boundary';
-}
-
-export function hasDashComments(language: string): boolean {
-    return rulesOf(language).dash;
-}
-
-export function hasBlockComments(language: string): boolean {
-    return rulesOf(language).block;
-}
-
-export function hasSlashComments(language: string): boolean {
-    return rulesOf(language).slash;
-}
-
-export function hasMarkupComments(language: string): boolean {
-    return rulesOf(language).markup;
-}
-
-/* Languages whose blocks are in braces: where a statement can be left open and a `case` label opens a block. */
 export function isBraced(language: string): boolean {
     return rulesOf(language).braced;
 }
@@ -103,9 +109,11 @@ export function hasSmartSemicolon(language: string): boolean {
 
 export function isWordCharacter(character: string): boolean {
     const code = character.charCodeAt(0);
+
     if (code < 128) {
         return (code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code === 95 || code === 36;
     }
+
     return /[\p{L}\p{N}_$]/u.test(character);
 }