@termaxjs/editor-core 0.1.1

package/dist/coordinates.js

@@ -0,0 +1,651 @@
+const lineStartsCache = new WeakMap();
+/**
+ * Compute or retrieve cached line starts table for a given lines array.
+ */
+export function computeLineStarts(lines) {
+    const cached = lineStartsCache.get(lines);
+    if (cached && cached.length === lines.length) {
+        return cached;
+    }
+    const starts = new Uint32Array(lines.length);
+    let acc = 0;
+    for (let i = 0; i < lines.length; i++) {
+        starts[i] = acc;
+        acc += (lines[i]?.length ?? 0) + 1;
+    }
+    lineStartsCache.set(lines, starts);
+    return starts;
+}
+/**
+ * Convert 0-indexed (line, column) to character offset in full text.
+ */
+export function positionToOffset(lines, pos) {
+    if (lines.length === 0)
+        return 0;
+    const targetLine = Math.max(0, Math.min(pos.line, lines.length - 1));
+    if (lines.length <= 16) {
+        let offset = 0;
+        for (let i = 0; i < targetLine; i++) {
+            offset += (lines[i]?.length ?? 0) + 1; // +1 for newline
+        }
+        if (targetLine >= 0 && targetLine < lines.length) {
+            offset += Math.min(pos.column, lines[targetLine]?.length ?? 0);
+        }
+        return offset;
+    }
+    const starts = computeLineStarts(lines);
+    const lineStart = starts[targetLine] ?? 0;
+    const lineLen = lines[targetLine]?.length ?? 0;
+    return lineStart + Math.min(pos.column, lineLen);
+}
+/**
+ * Convert character offset to 0-indexed (line, column).
+ */
+export function offsetToPosition(lines, offset) {
+    if (lines.length === 0)
+        return { line: 0, column: 0 };
+    if (offset <= 0)
+        return { line: 0, column: 0 };
+    if (lines.length <= 16) {
+        let current = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = lines[i]?.length ?? 0;
+            if (offset <= current + lineLen) {
+                return { line: i, column: Math.max(0, offset - current) };
+            }
+            current += lineLen + 1; // +1 for newline
+        }
+        const lastLine = Math.max(0, lines.length - 1);
+        return { line: lastLine, column: lines[lastLine]?.length ?? 0 };
+    }
+    const starts = computeLineStarts(lines);
+    let low = 0;
+    let high = lines.length - 1;
+    let lineIdx = 0;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        if (starts[mid] <= offset) {
+            lineIdx = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    const lineStart = starts[lineIdx] ?? 0;
+    const lineLen = lines[lineIdx]?.length ?? 0;
+    const column = Math.max(0, Math.min(offset - lineStart, lineLen));
+    return { line: lineIdx, column };
+}
+export function isLeadSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+export function isTrailSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+/**
+ * Step one code point backward, keeping surrogate pairs (emoji, astral CJK)
+ * whole so backspace never leaves a lone surrogate behind.
+ */
+export function stepBackCodePoint(text, offset) {
+    if (offset <= 0)
+        return 0;
+    if (isTrailSurrogate(text.charCodeAt(offset - 1)) &&
+        offset >= 2 &&
+        isLeadSurrogate(text.charCodeAt(offset - 2))) {
+        return offset - 2;
+    }
+    return offset - 1;
+}
+/**
+ * Step one code point forward, keeping surrogate pairs whole so
+ * forward-delete never leaves a lone surrogate behind.
+ */
+export function stepForwardCodePoint(text, offset) {
+    if (offset >= text.length)
+        return text.length;
+    if (isLeadSurrogate(text.charCodeAt(offset)) &&
+        offset + 1 < text.length &&
+        isTrailSurrogate(text.charCodeAt(offset + 1))) {
+        return offset + 2;
+    }
+    return offset + 1;
+}
+/**
+ * Convert pixel (x, y) coordinates to (line, column) position.
+ */
+export function pointToPosition(x, y, lineHeight, charWidth) {
+    const line = Math.max(0, Math.floor(y / Math.max(1, lineHeight)));
+    const column = Math.max(0, Math.round(x / Math.max(1, charWidth)));
+    return { line, column };
+}
+/**
+ * Convert (line, column) position to pixel (x, y) coordinates.
+ */
+export function positionToPoint(pos, lineHeight, charWidth) {
+    return {
+        x: pos.column * charWidth,
+        y: pos.line * lineHeight,
+    };
+}
+/**
+ * Clamp a position to valid buffer bounds.
+ */
+export function clampPosition(lines, pos) {
+    const total = lines.length;
+    if (total === 0)
+        return { line: 0, column: 0 };
+    const line = Math.max(0, Math.min(pos.line, total - 1));
+    const maxCol = Array.isArray(lines) ? (lines[line]?.length ?? 0) : 10000;
+    const column = Math.max(0, Math.min(pos.column, maxCol));
+    return { line, column };
+}
+/**
+ * Check if two positions are equal.
+ */
+export function arePositionsEqual(a, b) {
+    return a.line === b.line && a.column === b.column;
+}
+/**
+ * Check if position a is strictly before or equal to position b.
+ */
+export function isPositionBefore(a, b) {
+    if (a.line < b.line)
+        return true;
+    if (a.line > b.line)
+        return false;
+    return a.column <= b.column;
+}
+/**
+ * Normalize a Range ensuring start is before or equal to end.
+ */
+export function normalizeRange(range) {
+    if (isPositionBefore(range.start, range.end)) {
+        return { start: { ...range.start }, end: { ...range.end } };
+    }
+    return { start: { ...range.end }, end: { ...range.start } };
+}
+/**
+ * Check if a position lies within a Range (inclusive).
+ */
+export function isPositionInRange(pos, range) {
+    const norm = normalizeRange(range);
+    const afterStart = pos.line > norm.start.line || (pos.line === norm.start.line && pos.column >= norm.start.column);
+    const beforeEnd = pos.line < norm.end.line || (pos.line === norm.end.line && pos.column <= norm.end.column);
+    return afterStart && beforeEnd;
+}
+/**
+ * Find the word boundaries at a given column in a line of text.
+ */
+export function getWordRangeAt(lineText, line, column) {
+    if (lineText.length === 0) {
+        return { start: { line, column: 0 }, end: { line, column: 0 } };
+    }
+    const isWordChar = (c) => c !== undefined && /[a-zA-Z0-9_$]/.test(c);
+    let startCol = Math.max(0, Math.min(column, lineText.length));
+    let endCol = startCol;
+    if (startCol < lineText.length && isWordChar(lineText[startCol])) {
+        while (startCol > 0 && isWordChar(lineText[startCol - 1])) {
+            startCol--;
+        }
+        while (endCol < lineText.length && isWordChar(lineText[endCol])) {
+            endCol++;
+        }
+    }
+    else if (startCol > 0 && isWordChar(lineText[startCol - 1])) {
+        startCol--;
+        while (startCol > 0 && isWordChar(lineText[startCol - 1])) {
+            startCol--;
+        }
+    }
+    else {
+        const targetChar = lineText[startCol] ?? " ";
+        const isWhitespace = /\s/.test(targetChar);
+        if (isWhitespace) {
+            while (startCol > 0 && /\s/.test(lineText[startCol - 1] ?? ""))
+                startCol--;
+            while (endCol < lineText.length && /\s/.test(lineText[endCol] ?? ""))
+                endCol++;
+        }
+        else {
+            endCol = Math.min(lineText.length, startCol + 1);
+        }
+    }
+    return {
+        start: { line, column: startCol },
+        end: { line, column: endCol },
+    };
+}
+/**
+ * Extract text within a given Range across lines.
+ */
+export function getTextInRange(lines, range) {
+    if (!range)
+        return "";
+    const norm = normalizeRange(range);
+    if (norm.start.line === norm.end.line) {
+        if (norm.start.column === norm.end.column)
+            return "";
+        const line = lines[norm.start.line] ?? "";
+        return line.slice(norm.start.column, norm.end.column);
+    }
+    const result = [];
+    const firstLine = lines[norm.start.line] ?? "";
+    result.push(firstLine.slice(norm.start.column));
+    for (let l = norm.start.line + 1; l < norm.end.line; l++) {
+        result.push(lines[l] ?? "");
+    }
+    const lastLine = lines[norm.end.line] ?? "";
+    result.push(lastLine.slice(0, norm.end.column));
+    return result.join("\n");
+}
+/**
+ * Convert a Selection (anchor + head) to a normalized Range (start <= end).
+ */
+export function normalizeSelection(sel) {
+    return normalizeRange({ start: sel.anchor, end: sel.head });
+}
+/**
+ * Check if a selection is collapsed (anchor == head).
+ */
+export function isSelectionCollapsed(sel) {
+    return sel.anchor.line === sel.head.line && sel.anchor.column === sel.head.column;
+}
+/**
+ * Sort selections descending by maximum position (bottom-to-top, right-to-left).
+ * Necessary for multi-cursor mutations to avoid invalidating earlier offsets.
+ */
+export function sortSelectionsDescending(selections) {
+    return [...selections].sort((a, b) => {
+        const aMax = isPositionBefore(a.anchor, a.head) ? a.head : a.anchor;
+        const bMax = isPositionBefore(b.anchor, b.head) ? b.head : b.anchor;
+        if (aMax.line !== bMax.line)
+            return bMax.line - aMax.line;
+        return bMax.column - aMax.column;
+    });
+}
+/**
+ * Remove duplicate cursors/selections.
+ */
+export function deduplicateSelections(selections) {
+    const seen = new Set();
+    const result = [];
+    for (const sel of selections) {
+        const key = `${sel.anchor.line}:${sel.anchor.column}-${sel.head.line}:${sel.head.column}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(sel);
+        }
+    }
+    return result;
+}
+/**
+ * Apply text insertion across multiple cursors or selections in a single atomic pass.
+ */
+export function applyMultiCursorInsert(lines, selections, insertText) {
+    if (selections.length === 0) {
+        return { newLines: lines, newSelections: [] };
+    }
+    // Fast-path: single cursor/selection typing without line breaks (the 95% common user keystroke)
+    if (selections.length === 1 && !insertText.includes("\n") && !insertText.includes("\r")) {
+        const s = selections[0];
+        const norm = normalizeSelection(s);
+        if (norm.start.line === norm.end.line) {
+            const line = norm.start.line;
+            if (line >= 0 && line < lines.length) {
+                const lineStr = lines[line] ?? "";
+                const c1 = Math.max(0, Math.min(norm.start.column, lineStr.length));
+                const c2 = Math.max(0, Math.min(norm.end.column, lineStr.length));
+                const nextLines = lines.slice();
+                nextLines[line] = lineStr.slice(0, c1) + insertText + lineStr.slice(c2);
+                const newCol = c1 + insertText.length;
+                const newPos = { line, column: newCol };
+                return {
+                    newLines: nextLines,
+                    newSelections: [{ anchor: newPos, head: newPos }],
+                };
+            }
+        }
+    }
+    const fullText = lines.join("\n");
+    const ranges = selections.map((s, idx) => {
+        const norm = normalizeSelection(s);
+        return {
+            from: positionToOffset(lines, norm.start),
+            to: positionToOffset(lines, norm.end),
+            originalIndex: idx,
+        };
+    });
+    ranges.sort((a, b) => a.from - b.from || a.to - b.to);
+    const merged = [];
+    for (const r of ranges) {
+        if (merged.length > 0 && r.from <= merged[merged.length - 1].to) {
+            merged[merged.length - 1].to = Math.max(merged[merged.length - 1].to, r.to);
+        }
+        else {
+            merged.push({ ...r });
+        }
+    }
+    let result = "";
+    let lastEnd = 0;
+    const newOffsets = [];
+    for (const r of merged) {
+        result += fullText.slice(lastEnd, r.from);
+        const cursorOffset = result.length + insertText.length;
+        result += insertText;
+        newOffsets.push(cursorOffset);
+        lastEnd = r.to;
+    }
+    result += fullText.slice(lastEnd);
+    const nextLines = result.split(/\r?\n/);
+    const newSelections = newOffsets.map((offset) => {
+        const pos = offsetToPosition(nextLines, offset);
+        return { anchor: pos, head: pos };
+    });
+    return {
+        newLines: nextLines,
+        newSelections: deduplicateSelections(newSelections),
+    };
+}
+/**
+ * Apply deletion (backspace or forward delete) across multiple cursors or selections.
+ */
+export function applyMultiCursorDelete(lines, selections, isForward) {
+    if (selections.length === 0) {
+        return { newLines: lines, newSelections: [] };
+    }
+    const fullText = lines.join("\n");
+    const ranges = selections.map((s, idx) => {
+        const norm = normalizeSelection(s);
+        let from = positionToOffset(lines, norm.start);
+        let to = positionToOffset(lines, norm.end);
+        if (from === to) {
+            if (!isForward) {
+                from = stepBackCodePoint(fullText, from);
+            }
+            else {
+                to = stepForwardCodePoint(fullText, to);
+            }
+        }
+        return { from, to, originalIndex: idx };
+    });
+    ranges.sort((a, b) => a.from - b.from || a.to - b.to);
+    const merged = [];
+    for (const r of ranges) {
+        if (merged.length > 0 && r.from <= merged[merged.length - 1].to) {
+            merged[merged.length - 1].to = Math.max(merged[merged.length - 1].to, r.to);
+        }
+        else {
+            merged.push({ ...r });
+        }
+    }
+    let result = "";
+    let lastEnd = 0;
+    const newOffsets = [];
+    for (const r of merged) {
+        result += fullText.slice(lastEnd, r.from);
+        newOffsets.push(result.length);
+        lastEnd = r.to;
+    }
+    result += fullText.slice(lastEnd);
+    const nextLines = result.split(/\r?\n/);
+    const newSelections = newOffsets.map((offset) => {
+        const pos = offsetToPosition(nextLines, offset);
+        return { anchor: pos, head: pos };
+    });
+    return {
+        newLines: nextLines,
+        newSelections: deduplicateSelections(newSelections),
+    };
+}
+/**
+ * Find word boundary in a line of text for word-by-word cursor navigation (Ctrl/Alt + Arrow).
+ */
+export function findWordBoundary(lineText, column, direction) {
+    if (lineText.length === 0)
+        return 0;
+    const isWordChar = (c) => c !== undefined && /[a-zA-Z0-9_$]/.test(c);
+    const isSpace = (c) => c !== undefined && /\s/.test(c);
+    let col = Math.max(0, Math.min(column, lineText.length));
+    if (direction === -1) {
+        if (col === 0)
+            return 0;
+        // Step 1: skip whitespace to the left
+        while (col > 0 && isSpace(lineText[col - 1])) {
+            col--;
+        }
+        if (col === 0)
+            return 0;
+        // Step 2: if previous char is word char, jump to word start
+        if (isWordChar(lineText[col - 1])) {
+            while (col > 0 && isWordChar(lineText[col - 1])) {
+                col--;
+            }
+        }
+        else {
+            // Step 3: if previous char is punctuation/symbol, jump across same symbol group
+            while (col > 0 && !isWordChar(lineText[col - 1]) && !isSpace(lineText[col - 1])) {
+                col--;
+            }
+        }
+        return col;
+    }
+    // direction === 1 (forward)
+    if (col >= lineText.length)
+        return lineText.length;
+    // Step 1: if currently on whitespace, skip it
+    if (isSpace(lineText[col])) {
+        while (col < lineText.length && isSpace(lineText[col])) {
+            col++;
+        }
+    }
+    if (col >= lineText.length)
+        return lineText.length;
+    // Step 2: if on word char, jump to word end
+    if (isWordChar(lineText[col])) {
+        while (col < lineText.length && isWordChar(lineText[col])) {
+            col++;
+        }
+    }
+    else {
+        // Step 3: if on symbol, jump to symbol end
+        while (col < lineText.length && !isWordChar(lineText[col]) && !isSpace(lineText[col])) {
+            col++;
+        }
+    }
+    return col;
+}
+/**
+ * Toggle single-line comment on a range of lines.
+ */
+export function toggleLinesComment(lines, startLine, endLine, commentPrefix = "// ") {
+    const minLine = Math.max(0, Math.min(startLine, endLine));
+    const maxLine = Math.min(lines.length - 1, Math.max(startLine, endLine));
+    const prefixTrimmed = commentPrefix.trimEnd();
+    // Check if all non-empty lines are already commented
+    let allCommented = true;
+    let hasNonEmpty = false;
+    for (let l = minLine; l <= maxLine; l++) {
+        const line = lines[l] ?? "";
+        const trimmed = line.trimStart();
+        if (trimmed.length > 0) {
+            hasNonEmpty = true;
+            if (!trimmed.startsWith(prefixTrimmed)) {
+                allCommented = false;
+                break;
+            }
+        }
+    }
+    if (!hasNonEmpty) {
+        // If all selected lines are blank, comment the first line
+        const newLines = [...lines];
+        newLines[minLine] = commentPrefix;
+        return { newLines };
+    }
+    const newLines = [...lines];
+    if (allCommented) {
+        // Uncomment all lines
+        for (let l = minLine; l <= maxLine; l++) {
+            const line = lines[l] ?? "";
+            const match = line.match(/^(\s*)(.*)$/);
+            if (!match)
+                continue;
+            const indent = match[1] || "";
+            const content = match[2] || "";
+            if (content.startsWith(commentPrefix)) {
+                newLines[l] = indent + content.slice(commentPrefix.length);
+            }
+            else if (content.startsWith(prefixTrimmed)) {
+                newLines[l] = indent + content.slice(prefixTrimmed.length);
+            }
+        }
+    }
+    else {
+        // Find minimum indentation of non-empty lines
+        let minIndent = Number.POSITIVE_INFINITY;
+        for (let l = minLine; l <= maxLine; l++) {
+            const line = lines[l] ?? "";
+            if (line.trim().length > 0) {
+                const indentMatch = line.match(/^\s*/);
+                const indentLen = indentMatch ? indentMatch[0].length : 0;
+                if (indentLen < minIndent)
+                    minIndent = indentLen;
+            }
+        }
+        if (minIndent === Number.POSITIVE_INFINITY)
+            minIndent = 0;
+        for (let l = minLine; l <= maxLine; l++) {
+            const line = lines[l] ?? "";
+            if (line.length >= minIndent) {
+                newLines[l] = line.slice(0, minIndent) + commentPrefix + line.slice(minIndent);
+            }
+            else {
+                newLines[l] = " ".repeat(minIndent) + commentPrefix + line;
+            }
+        }
+    }
+    return { newLines };
+}
+/**
+ * Check if the cursor is directly between an open/close bracket pair (e.g. `(|)`),
+ * in which case backspace should delete both characters.
+ */
+export function isPairedBracketDelete(lineText, column) {
+    if (column <= 0 || column > lineText.length)
+        return false;
+    const left = lineText[column - 1];
+    const right = lineText[column];
+    if (!left || !right)
+        return false;
+    const pairs = {
+        "(": ")",
+        "[": "]",
+        "{": "}",
+        '"': '"',
+        "'": "'",
+        "`": "`",
+    };
+    return pairs[left] === right;
+}
+/**
+ * Compute rectangular / column selection spanning across multiple lines from start to end position.
+ * Returns an array of Selections, one for each line in the rectangular bounding box.
+ */
+export function computeColumnSelection(lines, start, end) {
+    if (lines.length === 0)
+        return [];
+    const minLine = Math.max(0, Math.min(start.line, end.line));
+    const maxLine = Math.min(lines.length - 1, Math.max(start.line, end.line));
+    const minCol = Math.min(start.column, end.column);
+    const maxCol = Math.max(start.column, end.column);
+    const isForward = start.column <= end.column;
+    const selections = [];
+    for (let l = minLine; l <= maxLine; l++) {
+        const lineLen = lines[l]?.length ?? 0;
+        const colA = Math.min(minCol, lineLen);
+        const colB = Math.min(maxCol, lineLen);
+        if (isForward) {
+            selections.push({
+                anchor: { line: l, column: colA },
+                head: { line: l, column: colB },
+            });
+        }
+        else {
+            selections.push({
+                anchor: { line: l, column: colB },
+                head: { line: l, column: colA },
+            });
+        }
+    }
+    return selections;
+}
+/**
+ * Compute column positions for vertical indent guides on a line of code.
+ */
+export function computeIndentGuides(lineText, tabSize = 2) {
+    if (tabSize <= 0)
+        return [];
+    const guides = [];
+    let leadingSpaces = 0;
+    for (let i = 0; i < lineText.length; i++) {
+        const ch = lineText[i];
+        if (ch === " ") {
+            leadingSpaces += 1;
+        }
+        else if (ch === "\t") {
+            leadingSpaces += tabSize - (leadingSpaces % tabSize);
+        }
+        else {
+            break;
+        }
+    }
+    const guideCount = Math.floor(leadingSpaces / tabSize);
+    for (let g = 0; g < guideCount; g++) {
+        guides.push(g * tabSize);
+    }
+    return guides;
+}
+/**
+ * Calculate rainbow bracket nesting depths and column positions across a line.
+ */
+export function computeRainbowBrackets(lineText, _language = "typescript", startDepth = 0) {
+    let depth = Math.max(0, startDepth);
+    const brackets = [];
+    let inString = null;
+    let isEscaped = false;
+    for (let i = 0; i < lineText.length; i++) {
+        const ch = lineText[i] ?? "";
+        if (isEscaped) {
+            isEscaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            isEscaped = true;
+            continue;
+        }
+        if (inString) {
+            if (ch === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            inString = ch;
+            continue;
+        }
+        // Line comments
+        if (ch === "/" && lineText[i + 1] === "/") {
+            break;
+        }
+        if (ch === "(" || ch === "[" || ch === "{") {
+            brackets.push({ col: i, depth, char: ch });
+            depth += 1;
+        }
+        else if (ch === ")" || ch === "]" || ch === "}") {
+            depth = Math.max(0, depth - 1);
+            brackets.push({ col: i, depth, char: ch });
+        }
+    }
+    return { nextDepth: depth, brackets };
+}
+//# sourceMappingURL=coordinates.js.map