@adecore/editor-core 0.0.1 → 0.17.0-beta.1

package/dist/lexical-folds.d.ts

@@ -0,0 +1,10 @@
+import type { FoldRole, FoldingRange } from './structure.ts';
+import type { DocumentLine } from './rope.ts';
+export declare function isImportLine(language: string, trimmed: string): boolean;
+export interface LexicalFoldOptions {
+    imports?: boolean;
+    regions?: boolean;
+    lineComments?: boolean;
+}
+export declare function rangeOf(startLine: number, endLine: number, getLine: (line: number) => DocumentLine, kind: FoldingRange['kind'], role?: FoldRole): FoldingRange;
+export declare function lexicalFolds(lineCount: number, getLine: (line: number) => DocumentLine, language: string, options?: LexicalFoldOptions): FoldingRange[];

package/dist/lexical-folds.js

@@ -0,0 +1,116 @@
+import { commentSyntax } from './languages.js';
+/* The words a line starts with when it brings another file in, by language. A language not listed here has no import list to fold. */
+const IMPORT_WORDS = new Map();
+function register(languages, words) {
+    // 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);
+    }
+}
+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');
+/* Whether a line, without its indentation, brings another file in. */
+export function isImportLine(language, trimmed) {
+    return IMPORT_WORDS.get(language.toLowerCase())?.test(trimmed) ?? false;
+}
+const REGION_START = /^\s*(?:\/\/|#|<!--|\/\*|--)\s*(?:#\s*)?region\b/;
+const REGION_END = /^\s*(?:\/\/|#|<!--|\/\*|--)\s*(?:#\s*)?endregion\b/;
+function bracketDelta(text) {
+    let depth = 0;
+    for (const character of text) {
+        if (character === '{' || character === '(' || character === '[') {
+            depth++;
+        }
+        else if (character === '}' || character === ')' || character === ']') {
+            depth--;
+        }
+    }
+    return depth;
+}
+/* A fold of whole lines, from the end of the first to the end of the last. */
+export function rangeOf(startLine, endLine, getLine, kind, role) {
+    const start = getLine(startLine);
+    return {
+        startLine,
+        endLine,
+        from: start.start + (start.text.length - start.text.trimStart().length),
+        to: getLine(endLine).end,
+        kind,
+        ...(role === undefined ? {} : { role })
+    };
+}
+/*
+ * The folds that come from how lines begin and need no syntax tree: a run of lines that import, a run
+ * of lines of line comments, and what sits between a `// region` line and its `// endregion`.
+ */
+export function lexicalFolds(lineCount, getLine, language, options = {}) {
+    const result = [];
+    const id = language.toLowerCase();
+    const words = options.imports === false ? undefined : IMPORT_WORDS.get(id);
+    const marker = options.lineComments === false ? null : commentSyntax(id).line;
+    const regions = [];
+    let importStart = -1;
+    let importEnd = -1;
+    let commentStart = -1;
+    let commentEnd = -1;
+    const flushImports = () => {
+        if (importStart !== -1 && importEnd > importStart) {
+            result.push(rangeOf(importStart, importEnd, getLine, 'imports', 'imports'));
+        }
+        importStart = -1;
+    };
+    const flushComments = () => {
+        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;
+        }
+        else if (trimmed !== '' && !(marker !== null && trimmed.startsWith(marker))) {
+            flushImports();
+        }
+    }
+    flushComments();
+    flushImports();
+    return result;
+}

package/dist/lexical.d.ts

@@ -0,0 +1,16 @@
+export declare const openers: Readonly<Record<string, string>>;
+export declare function startsWord(text: string, at: number): boolean;
+export declare function isScript(language: string): boolean;
+export declare function isPhp(language: string): boolean;
+export declare function hasHashComments(language: string): boolean;
+export declare function hashNeedsWordStart(language: string): boolean;
+export declare function hasDashComments(language: string): boolean;
+export declare function hasBlockComments(language: string): boolean;
+export declare function hasSlashComments(language: string): boolean;
+export declare function hasMarkupComments(language: string): boolean;
+export declare function isBraced(language: string): boolean;
+export declare function indentsByBrackets(language: string): boolean;
+export declare function hasSmartSemicolon(language: string): boolean;
+export declare function isWordCharacter(character: string): boolean;
+export declare function startsExpression(word: string): boolean;
+export declare function startsExpressionAfter(character: string): boolean;

package/dist/lexical.js

@@ -0,0 +1,74 @@
+export const openers = { '(': ')', '[': ']', '{': '}' };
+/* Words after which a `/` starts a regex and a `{` an object or a block, not a division or a statement end. */
+const expressionWords = /^(return|throw|case|yield|await|new|delete|typeof|void|in|of|instanceof)$/;
+/* Whether a `#` at this index stands where a word would start, after whitespace, a separator or an opener. */
+export function startsWord(text, at) {
+    return at === 0 || /[\s;|&(]/.test(text[at - 1]);
+}
+const NO_RULES = { slash: false, hash: false, dash: false, block: false, markup: false, braced: false };
+const languageRules = new Map();
+function register(ids, rules) {
+    for (const id of ids.split(' ')) {
+        languageRules.set(id, { ...NO_RULES, ...rules });
+    }
+}
+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 });
+register('css', { block: true });
+register('html xml svg xsl markdown md mdx', { markup: true });
+register('python py toml ruby rb dotenv ignore nix powershell ps1 properties julia jl elixir ex exs coffeescript coffee', { hash: 'any' });
+register('shellscript shell sh bash zsh fish yaml yml make makefile docker dockerfile cmake', { hash: 'boundary' });
+register('perl r graphql', { hash: 'any', braced: true });
+register('sql', { dash: true, block: true });
+register('lua haskell hs', { dash: true });
+function rulesOf(language) {
+    return languageRules.get(language.toLowerCase()) ?? NO_RULES;
+}
+export function isScript(language) {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|vue)$/i.test(language);
+}
+export function isPhp(language) {
+    return /^php$/i.test(language);
+}
+export function hasHashComments(language) {
+    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) {
+    return rulesOf(language).hash === 'boundary';
+}
+export function hasDashComments(language) {
+    return rulesOf(language).dash;
+}
+export function hasBlockComments(language) {
+    return rulesOf(language).block;
+}
+export function hasSlashComments(language) {
+    return rulesOf(language).slash;
+}
+export function hasMarkupComments(language) {
+    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) {
+    return rulesOf(language).braced;
+}
+/* Languages whose indentation follows their brackets, which Auto-indent Lines can work out. */
+export function indentsByBrackets(language) {
+    return (isBraced(language) && !/^(svelte|astro)$/i.test(language)) || /^css$/i.test(language);
+}
+export function hasSmartSemicolon(language) {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|php)$/i.test(language);
+}
+export function isWordCharacter(character) {
+    return /[\p{L}\p{N}_$]/u.test(character);
+}
+export function startsExpression(word) {
+    return expressionWords.test(word);
+}
+/* Whether what follows a punctuation character is an expression, so a `/` there is a regex. */
+export function startsExpressionAfter(character) {
+    return /[=,:;!?+\-*%&|^~<>]/.test(character);
+}

package/dist/line-commands.d.ts

@@ -0,0 +1,9 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection } from './types.ts';
+export interface LineCommandOptions {
+    language: string;
+    unit: string;
+}
+export declare function planJoinLines(source: EditSource, selections: readonly Selection[], options: LineCommandOptions): EditPlan | null;
+export declare function planToggleCase(source: EditSource, selections: readonly Selection[]): EditPlan | null;
+export declare function planAutoIndent(source: EditSource, lines: readonly number[], options: LineCommandOptions): EditPlan | null;

package/dist/line-commands.js

@@ -0,0 +1,306 @@
+import { commentSyntax } from './languages.js';
+import { continues } from './enter.js';
+import { indentsByBrackets } from './lexical.js';
+import { markupGuard } from './markup-regions.js';
+import { mapOffset } from './offsets.js';
+const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
+function rangeOf(selection) {
+    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+}
+function whitespaceOf(text) {
+    return /^[\t ]*/.exec(text)[0];
+}
+function isBlank(text) {
+    return text.trim() === '';
+}
+/* How far the edits in front of an offset moved it. An edit that starts at the offset is not in front of it. */
+function shiftBefore(offset, edits) {
+    return edits.filter((edit) => edit.from < offset).reduce((sum, edit) => sum + edit.text.length - (Math.min(edit.to, offset) - edit.from), 0);
+}
+/* The offset of the first character after `from` that is not whitespace, line breaks included. */
+function skipWhitespace(source, from) {
+    const last = source.line(source.lineCount - 1).end;
+    let offset = from;
+    while (offset < last && /\s/.test(source.charAt(offset))) {
+        offset++;
+    }
+    return offset;
+}
+/* What goes where two lines meet: nothing before a closer, a comma or a dot and after an opener, else a space. */
+function spacingBetween(previous, next) {
+    if (next === '' || /^[)\],;]/.test(next) || /^\.(?![.\d])/.test(next) || /[([]$/.test(previous)) {
+        return '';
+    }
+    return ' ';
+}
+/* The comment a line ends in, as its start and the marker it opens with. */
+function endComment(source, options, line) {
+    const bounds = source.line(line);
+    const syntax = commentSyntax(options.language, source.region(line));
+    const context = source.context(bounds.end);
+    if (context.mode !== 'line-comment' || context.commentStart === undefined || context.commentStart < bounds.start || syntax.line === null) {
+        return null;
+    }
+    return { start: context.commentStart, marker: syntax.line };
+}
+/* One join of a line with the next content after it. */
+function joinAfter(source, options, index) {
+    const left = source.line(index);
+    const next = skipWhitespace(source, left.end);
+    const trimmedEnd = left.start + left.text.trimEnd().length;
+    const nextLine = source.line(source.lineAt(next));
+    const content = source.slice(next, nextLine.end).trimEnd();
+    if (isBlank(left.text)) {
+        return { from: left.start, to: nextLine.start, text: '', caret: whitespaceOf(nextLine.text).length };
+    }
+    const comment = endComment(source, options, index);
+    if (comment) {
+        const marker = comment.marker.trimEnd();
+        if (content.startsWith(marker)) {
+            const rest = content.slice(marker.length);
+            const dropped = next + marker.length + (rest.startsWith(' ') ? 1 : 0);
+            const remainder = rest.startsWith(' ') ? rest.slice(1) : rest;
+            return { from: trimmedEnd, to: dropped, text: remainder === '' ? '' : ' ', caret: 0 };
+        }
+    }
+    return { from: trimmedEnd, to: next, text: spacingBetween(source.slice(left.start, trimmedEnd), content), caret: 0 };
+}
+/*
+ * Joins each line with the next, or the lines of a selection into one. The break and the whitespace
+ * around it become a space, a `//` comment line joined to another loses its second marker and the
+ * end of line comment of a line that code follows becomes a block comment.
+ */
+export function planJoinLines(source, selections, options) {
+    const ranges = [];
+    for (const selection of selections) {
+        const { from, to } = rangeOf(selection);
+        const first = source.lineAt(from);
+        let last = from === to ? first + 1 : source.lineAt(to);
+        if (from !== to && last > first && source.line(last).start === to) {
+            last--;
+        }
+        if (last >= source.lineCount) {
+            continue;
+        }
+        const previous = ranges.at(-1);
+        if (previous && first <= previous.first + previous.count) {
+            previous.count = Math.max(previous.count, last - previous.first);
+        }
+        else {
+            ranges.push({ first, count: last - first });
+        }
+    }
+    const edits = [];
+    const carets = [];
+    for (const range of ranges) {
+        let line = range.first;
+        for (let done = 0; done < range.count && line < source.lineCount - 1; done++) {
+            const join = joinAfter(source, options, line);
+            if (!join) {
+                break;
+            }
+            const comment = endComment(source, options, line);
+            const nextStart = skipWhitespace(source, source.line(line).end);
+            const nextLine = source.line(source.lineAt(nextStart));
+            const converts = comment !== null &&
+                !isBlank(source.slice(source.line(line).start, comment.start)) &&
+                !source.slice(nextStart, nextLine.end).startsWith(comment.marker.trimEnd()) &&
+                commentSyntax(options.language, source.region(line)).block?.open === '/*';
+            if (converts && comment) {
+                const body = source.slice(comment.start + comment.marker.length, join.from);
+                if (!body.includes('*/')) {
+                    edits.push({ from: comment.start, to: comment.start + comment.marker.length, text: '/*' });
+                    const closing = (body.startsWith(' ') && !body.endsWith(' ') ? ' ' : '') + '*/';
+                    edits.push({ from: join.from, to: join.to, text: closing + join.text });
+                    carets.push({ at: join.from, extra: closing.length });
+                    line = source.lineAt(nextStart);
+                    continue;
+                }
+            }
+            edits.push({ from: join.from, to: join.to, text: join.text });
+            carets.push({ at: join.from, extra: join.caret });
+            line = source.lineAt(nextStart);
+        }
+    }
+    if (edits.length === 0) {
+        return null;
+    }
+    edits.sort((left, right) => left.from - right.from);
+    const result = selections.map((selection) => {
+        const { from, to } = rangeOf(selection);
+        if (from !== to) {
+            const end = mapOffset(to, edits);
+            return { anchor: end, head: end };
+        }
+        const line = source.line(source.lineAt(from));
+        const caret = carets.find((entry) => entry.at >= line.start && entry.at <= line.end);
+        const base = caret ? caret.at + shiftBefore(caret.at, edits) + caret.extra : mapOffset(from, edits);
+        return { anchor: base, head: base };
+    });
+    return { edits, selections: result };
+}
+/* The identifier characters around an offset. */
+function wordAround(source, offset) {
+    const line = source.line(source.lineAt(offset));
+    const column = offset - line.start;
+    let from = column;
+    let to = column;
+    while (from > 0 && identifier.test(line.text[from - 1])) {
+        from--;
+    }
+    while (to < line.text.length && identifier.test(line.text[to])) {
+        to++;
+    }
+    return { from: line.start + from, to: line.start + to };
+}
+/* A string escape such as `\n` stays as written. */
+function convertCase(text, lower, inString) {
+    const convert = (part) => (lower ? part.toLowerCase() : part.toUpperCase());
+    if (!inString) {
+        return convert(text);
+    }
+    return text
+        .split(/(\\(?:u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|.))/)
+        .map((part, index) => (index % 2 === 1 ? part : convert(part)))
+        .join('');
+}
+/*
+ * Flips the case of what is selected, or of the word at a caret with nothing selected, which stays
+ * selected. Text with any capital turns to lower case, and text without turns to upper case; with
+ * several carets one answer goes for all of them.
+ */
+export function planToggleCase(source, selections) {
+    const targets = selections.map((selection) => {
+        const { from, to } = rangeOf(selection);
+        return from === to ? { ...wordAround(source, from), word: true } : { from, to, word: false };
+    });
+    const texts = targets.map((target) => source.slice(target.from, target.to));
+    const lower = texts.some((text) => text !== text.toLowerCase());
+    const edits = [];
+    const result = [];
+    let delta = 0;
+    for (const [index, target] of targets.entries()) {
+        const context = source.context(target.from);
+        const inString = context.mode === 'quote' || context.mode === 'template';
+        const converted = convertCase(texts[index], lower, inString);
+        if (converted !== texts[index]) {
+            edits.push({ from: target.from, to: target.to, text: converted });
+        }
+        const selection = selections[index];
+        const reversed = selection.anchor > selection.head;
+        const start = target.from + delta;
+        const end = target.from + delta + converted.length;
+        result.push(target.word || !reversed ? { anchor: start, head: end } : { anchor: end, head: start });
+        delta += converted.length - texts[index].length;
+    }
+    if (targets.every((target) => target.from === target.to)) {
+        return null;
+    }
+    return { edits, selections: result };
+}
+/* The brackets still open at the start of a line, innermost first. */
+function frames(context) {
+    const result = [];
+    for (let bracket = context.bracket; bracket; bracket = bracket.previous) {
+        result.push({ opener: bracket.at, closer: bracket.close });
+    }
+    return result;
+}
+const caseLabel = /^(?:case\b[^]*|default)\s*:$/;
+/*
+ * Sets the indentation of the lines to what their brackets say: a line is one level in from the line
+ * its innermost bracket opened on, a closing bracket lines up with it, the lines of a case follow
+ * their label and a line after an unfinished statement goes in once. Lines in comments and strings,
+ * and in languages that are not bracketed, are left alone.
+ */
+export function planAutoIndent(source, lines, options) {
+    if (!indentsByBrackets(options.language)) {
+        return null;
+    }
+    const indents = new Map();
+    const indentOf = (line) => indents.get(line) ?? whitespaceOf(source.line(line).text);
+    const edits = [];
+    const isMarkup = markupGuard(source, options.language);
+    for (const line of lines) {
+        const bounds = source.line(line);
+        const context = source.context(bounds.start);
+        if (isBlank(bounds.text) || context.mode !== 'code' || isMarkup(line)) {
+            continue;
+        }
+        const target = targetIndent(source, options, line, context, indentOf);
+        indents.set(line, target);
+        const current = whitespaceOf(bounds.text);
+        if (current !== target) {
+            edits.push({ from: bounds.start, to: bounds.start + current.length, text: target });
+        }
+    }
+    return edits.length === 0 ? null : { edits, selections: [] };
+}
+function targetIndent(source, options, line, context, indentOf) {
+    const text = source.line(line).text.trimStart();
+    const open = frames(context);
+    const innermost = open[0];
+    if (innermost && text.startsWith(innermost.closer)) {
+        return indentOf(source.lineAt(innermost.opener));
+    }
+    let base = innermost ? indentOf(source.lineAt(innermost.opener)) + options.unit : '';
+    if (innermost?.closer === '}' && !caseLabel.test(text)) {
+        const label = openCaseLabel(source, line, context.bracket);
+        if (label !== null) {
+            base = indentOf(label) + options.unit;
+        }
+    }
+    const previous = previousCodeLine(source, line);
+    if (previous !== null && source.context(source.line(previous).start).bracket === context.bracket && lineContinues(source, options, previous)) {
+        return isContinuation(source, options, previous) ? indentOf(previous) : indentOf(previous) + options.unit;
+    }
+    return base;
+}
+function lineContinues(source, options, line) {
+    const bounds = source.line(line);
+    const text = bounds.text.trimEnd();
+    return text.length > 0 && continues(text, source.context(bounds.start + text.length), options.language);
+}
+/* Whether the line goes on with a statement the line before it left open. */
+function isContinuation(source, options, line) {
+    const previous = previousCodeLine(source, line);
+    return (previous !== null &&
+        source.context(source.line(previous).start).bracket === source.context(source.line(line).start).bracket &&
+        lineContinues(source, options, previous));
+}
+function previousCodeLine(source, line) {
+    for (let candidate = line - 1; candidate >= 0; candidate--) {
+        if (!isBlank(source.line(candidate).text)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/* Whether `bracket` is `outer` or sits inside it. */
+function within(bracket, outer) {
+    for (let current = bracket;; current = current.previous) {
+        if (current === outer) {
+            return true;
+        }
+        if (!current) {
+            return false;
+        }
+    }
+}
+/* The line of the `case` label the lines of this block run under, if there is one. */
+function openCaseLabel(source, line, block) {
+    for (let candidate = line - 1; candidate >= 0 && candidate >= line - 200; candidate--) {
+        const bounds = source.line(candidate);
+        if (isBlank(bounds.text)) {
+            continue;
+        }
+        const state = source.context(bounds.start).bracket;
+        if (!within(state, block)) {
+            return null;
+        }
+        if (state === block && caseLabel.test(bounds.text.trim())) {
+            return candidate;
+        }
+    }
+    return null;
+}

package/dist/markup-regions.d.ts

@@ -0,0 +1,8 @@
+import type { EditSource } from './edit-source.ts';
+export declare function jsxRanges(text: string): {
+    from: number;
+    to: number;
+}[];
+export declare function hasJsx(language: string): boolean;
+export declare function isJsxAttributeValue(text: string, offset: number): boolean;
+export declare function markupGuard(source: EditSource, language: string): (line: number) => boolean;