import { EditorView } from '@codemirror/view' import { EditorSelection, EditorState, SelectionRange } from '@codemirror/state' import { ensureSyntaxTree, foldedRanges, foldEffect, syntaxTree, } from '@codemirror/language' import { SyntaxNode } from '@lezer/common' import { ancestorOfNodeWithType, isUnknownCommandWithName, } from '../utils/tree-query' export const wrapRanges = ( prefix: string, suffix: string, wrapWholeLine = false, selection?: (range: SelectionRange) => SelectionRange ) => (view: EditorView): boolean => { if (view.state.readOnly) { return false } view.dispatch( view.state.changeByRange(range => { const insert = { prefix, suffix } if (wrapWholeLine) { const line = view.state.doc.lineAt(range.anchor) if (range.empty) { // expand range to cover the whole line range = EditorSelection.range(line.from, line.to) } // add a newline at the start if needed if (range.from !== line.from) { insert.prefix = `\n${prefix}` } // add a newline at the end if needed if (range.to !== line.to) { insert.suffix = `${suffix}\n` } } const content = view.state.sliceDoc(range.from, range.to) // map through the prefix only const changedRange = range.map( view.state.changes([ { from: range.from, insert: `${insert.prefix}` }, ]), 1 ) return { range: selection ? selection(changedRange) : changedRange, // create a single change, including the content changes: [ { from: range.from, to: range.to, insert: `${insert.prefix}${content}${insert.suffix}`, }, ], } }), { scrollIntoView: true } ) return true } export const changeCase = (upper = true) => (view: EditorView) => { if (view.state.readOnly) { return false } view.dispatch( view.state.changeByRange(range => { // ignore empty ranges if (range.empty) { return { range } } const text = view.state.doc.sliceString(range.from, range.to) return { range, changes: [ { from: range.from, to: range.to, insert: upper ? text.toUpperCase() : text.toLowerCase(), }, ], } }) ) return true } export const duplicateSelection = (view: EditorView) => { if (view.state.readOnly) { return false } const foldedRangesInDocument = foldedRanges(view.state) view.dispatch( view.state.changeByRange(range => { const folds: { offset: number; base: number; length: number }[] = [] if (range.empty) { const line = view.state.doc.lineAt(range.from) let lineStart = line.from let lineEnd = line.to // Calculate line start/end including folded ranges // // Note that at each iteration of the while loop, new folded ranges // can be included. This happens when there are multiple folded ranges // on a single editor line (but spanning multiple actual lines) // // For example, the following document: // 1: \begin{document} // 2: test // 3: \end{document}\begin{document} // 4: test // 5: \end{document} // // Can be folded to: // \begin{document}<...>\end{document}\begin{document}<...>\end{document} // // In this case, the first iterations of the while loop below will only // include lines 3-5, since the overlapping folded range for line 5 // is only the fold on lines 3-5. Hence in the while loop, we expand the // selection until we include all the ranges. let changed do { changed = false foldedRangesInDocument.between(lineStart, lineEnd, (from, to) => { const newLineStart = Math.min( view.state.doc.lineAt(from).from, lineStart ) const newLineEnd = Math.max(view.state.doc.lineAt(to).to, lineEnd) if (newLineStart !== lineStart || newLineEnd !== lineEnd) { changed = true lineStart = newLineStart lineEnd = newLineEnd } }) } while (changed) // Collect information needed to fold duplicated lines foldedRangesInDocument.between(lineStart, lineEnd, (from, to) => { folds.push({ offset: from - lineStart, base: lineEnd + view.state.lineBreak.length, length: to - from, }) }) // Duplicate the selected lines downwards return { range, changes: [ { from: lineEnd, insert: view.state.lineBreak + view.state.doc.slice(lineStart, lineEnd), }, ], // Add a fold effect for each fold in the original line effects: folds.map(fold => foldEffect.of({ from: fold.base + fold.offset, to: fold.base + fold.offset + fold.length, }) ), } } else { // Duplicate selected text at head of selection let newSelectionRange = range if (range.head > range.anchor) { // Duplicating to the right, so we need to update the selected range newSelectionRange = EditorSelection.range( range.head, range.head + (range.to - range.from) ) } return { // The new range is the duplicated section, placed at the head of the // original selection range: newSelectionRange, changes: [ { from: range.head, insert: view.state.doc.slice(range.from, range.to), }, ], } } }) ) return true } function getParentNode( position: number | SyntaxNode, state: EditorState, assoc: 0 | 1 | -1 = 1 ): SyntaxNode | undefined { const tree = ensureSyntaxTree(state, 1000) let node: SyntaxNode | undefined | null = null if (typeof position === 'number') { node = tree?.resolveInner(position, assoc)?.parent // HACK: Spaces after UnknownCommands (and other commands without arguments) // are included in the Command node. So we have to adjust for that here. const preceedingCharacter = state.sliceDoc( Math.max(0, position - 1), position ) if ( preceedingCharacter === ' ' && ['UnknownCommand', 'Item', 'Left', 'Right'].some(name => node?.type.is(name) ) ) { node = ancestorOfNodeWithType(node, 'Command')?.parent } } else { node = position?.parent } while ( ['LongArg', 'TextArgument', 'OpenBrace', 'CloseBrace'].includes( node?.type.name || '' ) ) { node = node!.parent } return node || undefined } function wrapRangeInCommand( state: EditorState, range: SelectionRange, command: string ) { const content = state.sliceDoc(range.from, range.to) const changes = state.changes([ { from: range.from, to: range.to, insert: `${command}{${content}}`, }, ]) return { changes, range: moveRange( range, range.from + command.length + 1, range.from + command.length + content.length + 1 ), } } function moveRange(range: SelectionRange, newFrom: number, newTo: number) { const forwards = range.from === range.anchor return forwards ? EditorSelection.range(newFrom, newTo) : EditorSelection.range(newTo, newFrom) } function validateReplacement(expected: string, actual: string) { if (expected !== actual) { throw new Error( `Replacement in toggleRange failed validation. Expected ${expected} got ${actual}` ) } } function getWrappingAncestor( node: SyntaxNode, command: string, state: EditorState ): SyntaxNode | null { for ( let ancestor: SyntaxNode | null = node; ancestor; ancestor = ancestor.parent ) { if (isUnknownCommandWithName(ancestor, command, state)) { return ancestor } if (ancestor.type.is('UnknownCommand')) { // We could multiple levels deep in bold/non-bold. So bail out in this case return null } } return null } function adjustRangeIfNeeded( command: string, range: SelectionRange, state: EditorState ) { // Try to adjust the selection, if it is either // 1. \textbf<{test>} // 2. \textbf{ // 3. \textbf<{test}> // 4. <\textbf{test}> // 4. \textbf<>{test} const tree = syntaxTree(state) if (tree.length < range.to) { return range } const nodeLeft = tree.resolveInner(range.from, 1) const nodeRight = tree.resolveInner(range.to, -1) const parentLeft = getWrappingAncestor(nodeLeft, command, state) const parentRight = getWrappingAncestor(nodeRight, command, state) const parent = getParentNode(nodeLeft, state) if (parent?.type.is('UnknownCommand') && spansWholeArgument(parent, range)) { return bubbleUpRange( command, ancestorOfNodeWithType(nodeLeft, 'UnknownCommand'), range, state ) } if (!parentLeft) { // We're not trying to unbold, so don't bother adjusting range return bubbleUpRange( command, ancestorOfNodeWithType(nodeLeft, 'UnknownCommand'), range, state ) } if (nodeLeft.type.is('CtrlSeq') && range.from === range.to) { const command = nodeLeft.parent?.parent if (!command) { return range } return EditorSelection.cursor(command.from) } let { from, to } = range if (nodeLeft.type.is('CtrlSeq')) { from = nodeLeft.to + 1 } if (nodeLeft.type.is('OpenBrace')) { from = nodeLeft.to } // We know that parentLeft is the UnknownCommand, so now we check if we're // to the right of the closing brace. (parent is TextArgument, grandparent is // UnknownCommand) if (parentLeft === parentRight && nodeRight.type.is('CloseBrace')) { to = nodeRight.from } return bubbleUpRange(command, parentLeft, moveRange(range, from, to), state) } function spansWholeArgument( commandNode: SyntaxNode | null, range: SelectionRange ): boolean { const argument = commandNode?.getChild('TextArgument')?.getChild('LongArg') const res = Boolean( argument && argument.from === range.from && argument.to === range.to ) return res } function bubbleUpRange( command: string, node: SyntaxNode | null, range: SelectionRange, state: EditorState ) { let currentRange = range for ( let ancestorCommand: SyntaxNode | null = ancestorOfNodeWithType( node, 'UnknownCommand' ); spansWholeArgument(ancestorCommand, currentRange); ancestorCommand = ancestorOfNodeWithType( ancestorCommand.parent, 'UnknownCommand' ) ) { if (!ancestorCommand) { break } currentRange = moveRange( currentRange, ancestorCommand.from, ancestorCommand.to ) if (isUnknownCommandWithName(ancestorCommand, command, state)) { const argumentNode = ancestorCommand .getChild('TextArgument') ?.getChild('LongArg') if (!argumentNode) { return range } return moveRange(range, argumentNode.from, argumentNode.to) } } return range } export function toggleRanges(command: string) { /* There are a number of situations we need to handle in this function. * In the following examples, the selection range is marked within <> * 1. If the parent node at start and end of selection is different -> do * nothing & show error. Case 8 is an exception to this. * -> For good and bad, this disallows \textbf{this do} * 2. If selection contains a BlankLine (i.e. two newlines in a row) -> do * nothing & show error * -> \textbf doesn't allow paragraph breaks). * 3. If the selection is not within a \textbf -> wrap it in a \textbf * 4. If selection is at the beginning of a \textbf -> shrink the \textbf * command * -> e.g. \textbf{ a test} → \textbf{ a test} * 5. Similarly for selection at end of \textbf command * 6. If selection is in the middle of a \textbf command -> split the command * into two * -> e.g. \textbf{this test} → \textbf{this }\textbf{ test} * 7. If the selection is a whole \textbf command → remove the wrapping * command. * 8. If the selection spans two \textbf's with the same parent then join the * two * -> e.g. \textbf{this st} → \textbf{this st} * 9. If the selection spans the end of a \textbf, into the parent of the * command, then extend the \textbf. * -> e.g. \textbf{this → \textbf{this } * 10. Similarly for selections spanning the beginning of the selection */ return (view: EditorView): boolean => { if (view.state.readOnly) { return false } view.dispatch( view.state.changeByRange(initialRange => { const range = adjustRangeIfNeeded(command, initialRange, view.state) const content = view.state.sliceDoc(range.from, range.to) const ancestorAtStartOfRange = getParentNode( range.from, view.state, range.from === 0 ? 1 : -1 ) const ancestorAtEndOfRange = range.empty ? ancestorAtStartOfRange : getParentNode( range.to, view.state, range.to === view.state.doc.length ? -1 : 1 ) if (ancestorAtStartOfRange !== ancestorAtEndOfRange) { // But handle the exception of case 8 const ancestorAtStartIsWrappingCommand = ancestorAtStartOfRange && isUnknownCommandWithName( ancestorAtStartOfRange, command, view.state ) const ancestorAtEndIsWrappingCommand = ancestorAtEndOfRange && isUnknownCommandWithName(ancestorAtEndOfRange, command, view.state) if ( ancestorAtStartIsWrappingCommand && ancestorAtEndIsWrappingCommand && ancestorAtStartOfRange?.parent?.parent && ancestorAtEndOfRange?.parent?.parent ) { // Test for case 8 const nextAncestorAtStartOfRange = ancestorAtStartOfRange.parent.parent const nextAncestorAtEndOfRange = ancestorAtEndOfRange.parent.parent if (nextAncestorAtStartOfRange === nextAncestorAtEndOfRange) { // Join the two ranges const textBetweenRanges = view.state.sliceDoc( ancestorAtStartOfRange.to, ancestorAtEndOfRange.from ) const ancestorStartArgumentNode = ancestorAtStartOfRange.lastChild?.getChild('LongArg') const ancestorEndArgumentNode = ancestorAtEndOfRange.lastChild?.getChild('LongArg') if (!ancestorStartArgumentNode || !ancestorEndArgumentNode) { throw new Error("Can't find argument node") } const actualContent = view.state.sliceDoc( ancestorAtStartOfRange.from, ancestorAtEndOfRange.to ) const firstCommandArgument = view.state.sliceDoc( ancestorStartArgumentNode.from, ancestorStartArgumentNode.to ) const secondCommandArgument = view.state.sliceDoc( ancestorEndArgumentNode.from, ancestorEndArgumentNode.to ) validateReplacement( `${command}{${firstCommandArgument}}${textBetweenRanges}${command}{${secondCommandArgument}}`, actualContent ) const changes = view.state.changes([ { from: ancestorAtStartOfRange.from, to: ancestorAtEndOfRange.to, insert: `${command}{${firstCommandArgument}${textBetweenRanges}${secondCommandArgument}}`, }, ]) return { changes, range: moveRange( range, range.from, range.to - command.length - 1 - 1 ), } } } if ( ancestorAtEndIsWrappingCommand && ancestorAtEndOfRange.parent?.parent === ancestorAtStartOfRange ) { // Extend to the left. Case 10 const contentUpToCommand = view.state.sliceDoc( range.from, ancestorAtEndOfRange.from ) const ancestorEndArgumentNode = ancestorAtEndOfRange.lastChild?.getChild('LongArg') if (!ancestorEndArgumentNode) { throw new Error("Can't find argument node") } const commandContent = view.state.sliceDoc( ancestorEndArgumentNode.from, ancestorEndArgumentNode.to ) const actualContent = view.state.sliceDoc( range.from, ancestorAtEndOfRange.to ) validateReplacement( `${contentUpToCommand}${command}{${commandContent}}`, actualContent ) const changes = view.state.changes([ { from: range.from, to: ancestorAtEndOfRange.to, insert: `${command}{${contentUpToCommand}${commandContent}}`, }, ]) return { changes, range: moveRange( range, range.from + command.length + 1, range.to ), } } if ( ancestorAtStartIsWrappingCommand && ancestorAtStartOfRange.parent?.parent === ancestorAtEndOfRange ) { // Extend to the right. Case 9 const contentAfterCommand = view.state.sliceDoc( ancestorAtStartOfRange.to, range.to ) const ancestorStartArgumentNode = ancestorAtStartOfRange.lastChild?.getChild('LongArg') if (!ancestorStartArgumentNode) { throw new Error("Can't find argument node") } const commandContent = view.state.sliceDoc( ancestorStartArgumentNode.from, ancestorStartArgumentNode.to ) const actualContent = view.state.sliceDoc( ancestorAtStartOfRange.from, range.to ) validateReplacement( `${command}{${commandContent}}${contentAfterCommand}`, actualContent ) const changes = view.state.changes([ { from: ancestorAtStartOfRange.from, to: range.to, insert: `${command}{${commandContent}${contentAfterCommand}}`, }, ]) return { changes, range: moveRange(range, range.from, range.to - 1), } } // Bail out in case 1 // TODO: signal error to the user return { range } } const ancestor = ancestorAtStartOfRange // Bail out in case 2 if (content.includes('\n\n')) { // TODO: signal error to the user return { range } } const isCursorBeforeAncestor = range.empty && ancestor && range.from === ancestor.from && isUnknownCommandWithName(ancestor, command, view.state) // If we can't find an ancestor node, or if the parent is not an exsting // \textbf, then we just wrap it in a range. Case 3. if ( isCursorBeforeAncestor || !ancestor || !isUnknownCommandWithName(ancestor, command, view.state) ) { return wrapRangeInCommand(view.state, range, command) } const argumentNode = ancestor.lastChild?.getChild('LongArg') if (!argumentNode) { throw new Error("Can't find argument node") } // We should trim from the beginning. Case 4 if (range.from === argumentNode.from && range.to !== argumentNode.to) { const textAfterSelection = view.state.sliceDoc( range.to, argumentNode.to ) const wholeCommand = view.state.sliceDoc(ancestor.from, ancestor.to) validateReplacement( `${command}{${content}${textAfterSelection}}`, wholeCommand ) const changes = view.state.changes([ { from: ancestor.from, to: ancestor.to, insert: `${content}${command}{${textAfterSelection}}`, }, ]) return { range: moveRange( range, range.from - command.length - 1, range.to - command.length - 1 ), changes, } } // We should trim from the end. Case 5 if (range.to === argumentNode.to && range.from !== argumentNode.from) { const textBeforeSelection = view.state.sliceDoc( ancestor.from, range.from ) const wholeCommand = view.state.sliceDoc(ancestor.from, ancestor.to) validateReplacement(`${textBeforeSelection}${content}}`, wholeCommand) const changes = view.state.changes([ { from: ancestor.from, to: ancestor.to, insert: `${textBeforeSelection}}${content}`, }, ]) // We should shift selection forward by the } we insert return { range: moveRange(range, range.from + 1, range.to + 1), changes, } } // We should split the command in two. Case 6 if (range.from !== argumentNode.from && range.to !== argumentNode.to) { const textBeforeSelection = view.state.sliceDoc( ancestor.from, range.from ) const textAfterSelection = view.state.sliceDoc(range.to, ancestor.to) const wholeCommand = view.state.sliceDoc(ancestor.from, ancestor.to) validateReplacement( `${textBeforeSelection}${content}${textAfterSelection}`, wholeCommand ) const changes = view.state.changes([ { from: ancestor.from, to: ancestor.to, insert: `${textBeforeSelection}}${content}${command}{${textAfterSelection}`, }, ]) return { range: moveRange(range, range.from + 1, range.to + 1), changes, } } // Remove the wrapping command. Case 7 if (spansWholeArgument(ancestor, range)) { const argumentContent = view.state.sliceDoc( argumentNode.from, argumentNode.to ) const wholeCommand = view.state.sliceDoc(ancestor.from, ancestor.to) validateReplacement(`${command}{${content}}`, wholeCommand) const changes = view.state.changes([ { from: ancestor.from, to: ancestor.to, insert: argumentContent }, ]) return { range: moveRange( range, range.from - command.length - 1, range.to - command.length - 1 ), changes, } } // Shouldn't happen, but default to just wrapping the content return wrapRangeInCommand(view.state, range, command) }), { scrollIntoView: true } ) return true } }