overleaf/services/web/frontend/js/features/source-editor/extensions/visual-line-selection.ts
Mathias Jakobsen 5fd4504f51 Merge pull request #13061 from overleaf/mj-cm6-translations
[web] Make translations accessible to CM6

GitOrigin-RevId: ef617638419597548e6e0545bac3ac94216177de
2023-05-16 08:04:11 +00:00

160 lines
4.4 KiB
TypeScript

import {
SelectionRange,
EditorSelection,
EditorState,
Transaction,
} from '@codemirror/state'
import { Command, EditorView } from '@codemirror/view'
const getNextLineBoundary = (
selection: SelectionRange,
forward: boolean,
view: EditorView,
includeWrappingCharacter = false
) => {
const newSelection = view.moveToLineBoundary(
EditorSelection.cursor(
selection.head,
1,
selection.bidiLevel || undefined,
selection.goalColumn
),
forward
)
// Adjust to be "before" the simulated line break
let offset = 0
if (
forward &&
!includeWrappingCharacter &&
view.lineBlockAt(selection.head).to !== newSelection.head
) {
offset = 1
}
return EditorSelection.cursor(
newSelection.head - offset,
selection.assoc,
selection.bidiLevel || undefined,
newSelection.goalColumn
)
}
const changeSelection = (
view: EditorView,
how: (selection: SelectionRange) => SelectionRange,
extend = false
) => {
view.dispatch({
selection: EditorSelection.create(
view.state.selection.ranges.map(start => {
const newSelection = how(start)
const anchor = extend ? start.anchor : newSelection.head
return EditorSelection.range(
anchor,
newSelection.head,
newSelection.goalColumn,
newSelection.bidiLevel || undefined
)
}),
view.state.selection.mainIndex
),
scrollIntoView: true,
userEvent: 'select',
})
}
export const cursorToEndOfVisualLine = (view: EditorView) =>
changeSelection(view, range => getNextLineBoundary(range, true, view), false)
export const selectToEndOfVisualLine = (view: EditorView) =>
changeSelection(view, range => getNextLineBoundary(range, true, view), true)
export const selectRestOfVisualLine = (view: EditorView) =>
changeSelection(
view,
range => getNextLineBoundary(range, true, view, true),
true
)
export const cursorToBeginningOfVisualLine = (view: EditorView) =>
changeSelection(view, range => getNextLineBoundary(range, false, view), false)
export const selectToBeginningOfVisualLine = (view: EditorView) =>
changeSelection(view, range => getNextLineBoundary(range, false, view), true)
export const deleteToVisualLineEnd: Command = view =>
deleteBy(view, pos => {
const lineEnd = getNextLineBoundary(
EditorSelection.cursor(pos),
true,
view,
true
).to
return pos < lineEnd ? lineEnd : Math.min(view.state.doc.length, pos + 1)
})
export const deleteToVisualLineStart: Command = view =>
deleteBy(view, pos => {
const lineStart = getNextLineBoundary(
EditorSelection.cursor(pos),
false,
view
).to
return pos > lineStart ? lineStart : Math.max(0, pos - 1)
})
/* eslint-disable */
/**
* The following definitions are from CodeMirror 6, licensed under the MIT license:
* https://github.com/codemirror/commands/blob/main/src/commands.ts
*/
type CommandTarget = { state: EditorState; dispatch: (tr: Transaction) => void }
function deleteBy(target: CommandTarget, by: (start: number) => number) {
if (target.state.readOnly) return false
let event = 'delete.selection',
{ state } = target
let changes = state.changeByRange(range => {
let { from, to } = range
if (from == to) {
let towards = by(from)
if (towards < from) {
event = 'delete.backward'
towards = skipAtomic(target, towards, false)
} else if (towards > from) {
event = 'delete.forward'
towards = skipAtomic(target, towards, true)
}
from = Math.min(from, towards)
to = Math.max(to, towards)
} else {
from = skipAtomic(target, from, false)
to = skipAtomic(target, to, true)
}
return from == to
? { range }
: { changes: { from, to }, range: EditorSelection.cursor(from) }
})
if (changes.changes.empty) return false
target.dispatch(
state.update(changes, {
scrollIntoView: true,
userEvent: event,
effects:
event == 'delete.selection'
? EditorView.announce.of(state.phrase('selection_deleted'))
: undefined,
})
)
return true
}
function skipAtomic(target: CommandTarget, pos: number, forward: boolean) {
if (target instanceof EditorView)
for (let ranges of target.state
.facet(EditorView.atomicRanges)
.map(f => f(target)))
ranges.between(pos, pos, (from, to) => {
if (from < pos && to > pos) pos = forward ? to : from
})
return pos
}