655 lines
20 KiB
JavaScript
655 lines
20 KiB
JavaScript
const besUrl = 'http://localhost:225/api/v2/check'
|
|
|
|
let besEditors = [] // Collection of all editors on page
|
|
|
|
class BesEditor {
|
|
constructor(edit) {
|
|
this.el = edit
|
|
this.timer = null
|
|
this.children = []
|
|
const { correctionPanel, scrollPanel } = this.createCorrectionPanel(edit)
|
|
this.correctionPanel = correctionPanel
|
|
this.scrollPanel = scrollPanel
|
|
this.offsetTop = null
|
|
this.proof(edit)
|
|
edit.addEventListener('beforeinput', e => this.handleBeforeInput(e), false)
|
|
edit.addEventListener('click', e => this.handleClick(e))
|
|
edit.addEventListener('scroll', e =>
|
|
this.handleScrollEvent(edit, this.scrollPanel)
|
|
)
|
|
}
|
|
|
|
// Register editor
|
|
static register(edit) {
|
|
let editor = new BesEditor(edit)
|
|
besEditors.push(editor)
|
|
return editor
|
|
}
|
|
|
|
// TODO: add support for textarea elements
|
|
// Recursively grammar-proofs one node.
|
|
async proof(el) {
|
|
// If first child is not a block element, add a dummy <div>...</div> around it.
|
|
// This is solution is still not fully tested and might need some improvements.
|
|
if (el.classList?.contains('bes-online-editor')) {
|
|
const firstChild = el.firstChild
|
|
if (
|
|
firstChild &&
|
|
(firstChild.nodeType === Node.TEXT_NODE ||
|
|
!BesEditor.isBlockElement(firstChild))
|
|
) {
|
|
const divEl = document.createElement('div')
|
|
if (firstChild.nodeType === Node.TEXT_NODE) {
|
|
divEl.textContent = firstChild.textContent
|
|
} else divEl.appendChild(firstChild.cloneNode(true))
|
|
el.insertBefore(divEl, firstChild)
|
|
el.removeChild(firstChild)
|
|
}
|
|
}
|
|
|
|
switch (el.nodeType) {
|
|
case Node.TEXT_NODE:
|
|
return [{ text: el.textContent, el: el, markup: false }]
|
|
|
|
case Node.ELEMENT_NODE:
|
|
if (BesEditor.isBlockElement(el)) {
|
|
// Block elements are grammar-proofed independently.
|
|
if (this.isProofed(el)) {
|
|
return [{ text: '<' + el.tagName + '/>', el: el, markup: true }]
|
|
}
|
|
this.clearMistakeMarkup(el)
|
|
let data = []
|
|
for (const el2 of el.childNodes) {
|
|
data = data.concat(await this.proof(el2))
|
|
}
|
|
if (data.some(x => !x.markup && !/^\s*$/.test(x.text))) {
|
|
const requestData = {
|
|
format: 'plain',
|
|
data: JSON.stringify({
|
|
annotation: data.map(x =>
|
|
x.markup ? { markup: x.text } : { text: x.text }
|
|
)
|
|
}),
|
|
language: el.lang ? el.lang : 'sl',
|
|
level: 'picky'
|
|
}
|
|
const request = new Request(besUrl, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
|
|
body: new URLSearchParams(requestData)
|
|
})
|
|
fetch(request)
|
|
.then(response => {
|
|
if (!response.ok) {
|
|
// TODO: Make connectivity and BesStr issues non-fatal. But show an error sign somewhere in the UI.
|
|
throw new Error('Backend server response was not OK')
|
|
}
|
|
return response.json()
|
|
})
|
|
.then(responseData => {
|
|
let matches = []
|
|
responseData.matches.forEach(match => {
|
|
let range = document.createRange()
|
|
|
|
// Locate start of the grammar mistake.
|
|
for (
|
|
let idx = 0, startingOffset = 0;
|
|
;
|
|
startingOffset += data[idx++].text.length
|
|
) {
|
|
if (
|
|
!data[idx].markup &&
|
|
/*startingOffset <= match.offset &&*/ match.offset <
|
|
startingOffset + data[idx].text.length
|
|
) {
|
|
range.setStart(
|
|
data[idx].el,
|
|
match.offset - startingOffset
|
|
)
|
|
break
|
|
}
|
|
}
|
|
|
|
// Locate end of the grammar mistake.
|
|
let endOffset = match.offset + match.length
|
|
for (
|
|
let idx = 0, startingOffset = 0;
|
|
;
|
|
startingOffset += data[idx++].text.length
|
|
) {
|
|
if (
|
|
!data[idx].markup &&
|
|
/*startingOffset <= endOffset &&*/ endOffset <=
|
|
startingOffset + data[idx].text.length
|
|
) {
|
|
range.setEnd(data[idx].el, endOffset - startingOffset)
|
|
break
|
|
}
|
|
}
|
|
|
|
matches.push({
|
|
range: range,
|
|
rects: this.addMistakeMarkup(range, this.scrollPanel),
|
|
match: match
|
|
})
|
|
})
|
|
this.markProofed(el, matches)
|
|
})
|
|
.catch(error => {
|
|
// TODO: Make parsing issues non-fatal. But show an error sign somewhere in the UI.
|
|
throw new Error(
|
|
'Parsing backend server response failed: ' + error
|
|
)
|
|
})
|
|
}
|
|
return [{ text: '<' + el.tagName + '/>', el: el, markup: true }]
|
|
} else {
|
|
// Surround inline element with dummy <tagName>...</tagName>.
|
|
let data = [{ text: '<' + el.tagName + '>', el: el, markup: true }]
|
|
for (const el2 of el.childNodes) {
|
|
data = data.concat(await this.proof(el2))
|
|
}
|
|
data.splice(data.length, 0, {
|
|
text: '</' + el.tagName + '>',
|
|
markup: true
|
|
})
|
|
return data
|
|
}
|
|
|
|
default:
|
|
return [{ text: '<?' + el.nodeType + '>', el: el, markup: true }]
|
|
}
|
|
}
|
|
|
|
createCorrectionPanel(edit) {
|
|
const panelParent = document.createElement('div')
|
|
panelParent.classList.add('bes-correction-panel-parent')
|
|
const correctionPanel = document.createElement('div')
|
|
const scrollPanel = document.createElement('div')
|
|
this.setCorrectionPanelSize(edit, correctionPanel, scrollPanel)
|
|
correctionPanel.classList.add('bes-correction-panel')
|
|
scrollPanel.classList.add('bes-correction-panel-scroll')
|
|
|
|
correctionPanel.appendChild(scrollPanel)
|
|
panelParent.appendChild(correctionPanel)
|
|
edit.parentElement.insertBefore(panelParent, edit)
|
|
|
|
return { correctionPanel, scrollPanel }
|
|
}
|
|
|
|
// Marks section of text that is about to change as not-yet-grammar-proofed.
|
|
handleBeforeInput(event) {
|
|
if (this.timer) clearTimeout(this.timer)
|
|
let blockElements = new Set()
|
|
event.getTargetRanges().forEach(range => {
|
|
BesEditor.getNodesInRange(range).forEach(el =>
|
|
blockElements.add(this.getBlockParent(el))
|
|
)
|
|
})
|
|
blockElements.forEach(block => {
|
|
this.clearProofed(block)
|
|
this.clearMistakeMarkup(block)
|
|
this.clearChildren(block)
|
|
})
|
|
let editor = this
|
|
// Not the nice way to do it, but it works for now the repositionMistakes function is called before the DOM updates are finished.
|
|
setTimeout(() => {
|
|
editor.repositionMistakes(editor)
|
|
}, 0)
|
|
this.timer = setTimeout(function () {
|
|
editor.proof(editor.el)
|
|
}, 1000)
|
|
}
|
|
|
|
// Test if given block element has already been grammar-proofed.
|
|
isProofed(el) {
|
|
let filteredChildren = this.children.filter(child => child.elements === el)
|
|
return filteredChildren[0]?.isProofed
|
|
}
|
|
|
|
// Mark given block element as grammar-proofed.
|
|
markProofed(el, matches) {
|
|
let newChild = {
|
|
isProofed: true,
|
|
elements: el,
|
|
matches: matches
|
|
}
|
|
|
|
this.children = this.children.map(child =>
|
|
child.elements === newChild.elements ? newChild : child
|
|
)
|
|
if (!this.children.some(child => child.elements === newChild.elements)) {
|
|
this.children.push(newChild)
|
|
}
|
|
}
|
|
|
|
// Mark given block element as not grammar-proofed.
|
|
clearProofed(el) {
|
|
this.children
|
|
.filter(child => child.elements === el)
|
|
.forEach(child => {
|
|
child.isProofed = false
|
|
})
|
|
}
|
|
|
|
// Remove all grammar mistakes markup for given block element.
|
|
clearMistakeMarkup(el) {
|
|
this.children
|
|
.filter(child => child.elements === el)
|
|
.forEach(child => {
|
|
// TODO: Remove elements that are found in editor object, that way we can avoid looping through all elements.
|
|
child.matches.forEach(match => {
|
|
for (const rect of match.rects) {
|
|
for (let child of this.scrollPanel.children) {
|
|
let childRect = child.getBoundingClientRect()
|
|
const isWithinRect =
|
|
childRect.left >= rect.left &&
|
|
childRect.right <= rect.right &&
|
|
childRect.top >= rect.top &&
|
|
childRect.bottom <= rect.bottom + 20
|
|
if (isWithinRect) {
|
|
child.remove()
|
|
}
|
|
}
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// Remove all children from this.children array
|
|
clearChildren(el) {
|
|
if (el?.classList.contains('bes-online-editor')) return
|
|
else this.children = this.children.filter(child => child.elements !== el)
|
|
}
|
|
|
|
repositionMistakes(editor) {
|
|
editor.children.forEach(child => {
|
|
this.clearMistakeMarkup(child.elements)
|
|
child.matches.forEach(match => {
|
|
match.rects = this.addMistakeMarkup(match.range, this.scrollPanel)
|
|
})
|
|
})
|
|
}
|
|
|
|
// Adds grammar mistake markup
|
|
addMistakeMarkup(range, scrollPanel) {
|
|
// TODO: Consider using range.getClientRects() instead of range.getBoundingClientRect()
|
|
const clientRects = range.getClientRects()
|
|
const scrollPanelRect = scrollPanel.getBoundingClientRect()
|
|
for (let i = 0, n = clientRects.length; i < n; ++i) {
|
|
const rect = clientRects[i]
|
|
const highlight = document.createElement('div')
|
|
highlight.classList.add('bes-typo-mistake')
|
|
const topPosition = rect.top - scrollPanelRect.top
|
|
const leftPosition = rect.left - scrollPanelRect.left
|
|
highlight.style.left = `${leftPosition}px`
|
|
highlight.style.top = `${topPosition}px`
|
|
highlight.style.width = `${rect.width}px`
|
|
highlight.style.height = `${rect.height}px`
|
|
this.scrollPanel.appendChild(highlight)
|
|
}
|
|
return clientRects
|
|
}
|
|
|
|
// Tests if given element is block element.
|
|
static isBlockElement(el) {
|
|
switch (
|
|
document.defaultView
|
|
.getComputedStyle(el, null)
|
|
.getPropertyValue('display')
|
|
.toLowerCase()
|
|
) {
|
|
case 'inline':
|
|
case 'inline-block':
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
// Returns first block parent element
|
|
getBlockParent(el) {
|
|
for (; el && el !== this.el; el = el.parentNode) {
|
|
if (el.nodeType === Node.ELEMENT_NODE && BesEditor.isBlockElement(el))
|
|
return el
|
|
}
|
|
return el
|
|
}
|
|
|
|
static getNextNode(node) {
|
|
if (node.firstChild) return node.firstChild
|
|
while (node) {
|
|
if (node.nextSibling) return node.nextSibling
|
|
node = node.parentNode
|
|
}
|
|
}
|
|
|
|
static getParents(node) {
|
|
let parents = []
|
|
do {
|
|
parents.push(node)
|
|
node = node.parentNode
|
|
} while (node)
|
|
return parents.reverse()
|
|
}
|
|
|
|
static getNodesInRange(range) {
|
|
var start = range.startContainer
|
|
var end = range.endContainer
|
|
|
|
let startAncestors = BesEditor.getParents(start)
|
|
let endAncestors = BesEditor.getParents(end)
|
|
let commonAncestor = null
|
|
for (
|
|
let i = 0;
|
|
i < startAncestors.length &&
|
|
i < endAncestors.length &&
|
|
startAncestors[i] === endAncestors[i];
|
|
++i
|
|
) {
|
|
commonAncestor = startAncestors[i]
|
|
}
|
|
|
|
var nodes = []
|
|
var node
|
|
|
|
// walk parent nodes from start to common ancestor
|
|
for (node = start.parentNode; node; node = node.parentNode) {
|
|
nodes.push(node)
|
|
if (node == commonAncestor) break
|
|
}
|
|
nodes.reverse()
|
|
|
|
// walk children and siblings from start until end is found
|
|
for (node = start; node; node = BesEditor.getNextNode(node)) {
|
|
nodes.push(node)
|
|
if (node == end) break
|
|
}
|
|
|
|
return nodes
|
|
}
|
|
|
|
handleClick(e) {
|
|
const targetEl = e.target
|
|
const popup = document.querySelector('bes-popup-el')
|
|
// If target has not parent with class 'bes-online-editor', find target's parent whose parent is 'bes-online-editor'
|
|
const target = BesEditor.findParent(targetEl)
|
|
? BesEditor.findParent(targetEl)
|
|
: targetEl
|
|
|
|
const divIndex = this.children.findIndex(child => child.elements === target)
|
|
const matches = this.children[divIndex]?.matches
|
|
if (!matches) {
|
|
popup.hide()
|
|
return
|
|
}
|
|
if (
|
|
BesEditor.renderPopup(target, matches, popup, e.clientX, e.clientY, this)
|
|
)
|
|
return
|
|
else popup.hide()
|
|
}
|
|
|
|
handleScrollEvent(editor, scrollPanel) {
|
|
scrollPanel.style.top = -editor.scrollTop + 'px'
|
|
this.offsetTop = editor.scrollTop
|
|
}
|
|
|
|
static findParent(target) {
|
|
let element = target
|
|
while (element && element.parentNode) {
|
|
if (element.parentNode.classList?.contains('bes-online-editor')) {
|
|
return element
|
|
}
|
|
element = element.parentNode
|
|
}
|
|
return null
|
|
}
|
|
|
|
static renderPopup(el, matches, popup, clientX, clientY, editor) {
|
|
for (let m of matches) {
|
|
if (m.rects) {
|
|
for (let r of m.rects) {
|
|
if (BesEditor.isPointInRect(clientX, clientY, r, editor.offsetTop)) {
|
|
popup.changeText(m.match.message)
|
|
m.match.replacements.forEach(replacement => {
|
|
popup.appendReplacements(
|
|
el,
|
|
r,
|
|
m.match,
|
|
replacement.value,
|
|
editor
|
|
)
|
|
})
|
|
popup.show(clientX, clientY)
|
|
return true
|
|
}
|
|
}
|
|
} else {
|
|
popup.hide()
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
static replaceText(el, rect, match, replacement, editor) {
|
|
const text = el.textContent
|
|
const newText =
|
|
text.substring(0, match.offset) +
|
|
replacement +
|
|
text.substring(match.offset + match.length)
|
|
el.textContent = newText
|
|
BesEditor.clearSingleMistake(editor, el, rect)
|
|
// In my opinion, this approach provides the most straightforward solution for repositioning mistakes after a change.
|
|
// It maintains reasonable performance as it only checks the block element that has been modified,
|
|
// rather than re-evaluating the entire document or a larger set of elements.
|
|
editor.proof(el)
|
|
}
|
|
|
|
// This function clears a single mistake
|
|
static clearSingleMistake(editor, el, rect) {
|
|
const childToDelete = editor.children.filter(
|
|
child => child.elements === el
|
|
)[0]
|
|
childToDelete.isProofed = false
|
|
childToDelete.matches = childToDelete.matches.filter(
|
|
match => !BesEditor.isPointInRect(rect.left, rect.top, match.rects[0])
|
|
)
|
|
|
|
// TODO: find a better way to remove elements from the DOM
|
|
Array.from(editor.scrollPanel.children)
|
|
.filter(child => {
|
|
const childRect = child.getBoundingClientRect()
|
|
return BesEditor.isPointInRect(childRect.left, childRect.top, rect)
|
|
})
|
|
.forEach(child => child.remove())
|
|
}
|
|
|
|
setCorrectionPanelSize(editor, correctionPanel, scrollPanel) {
|
|
const styles = window.getComputedStyle(editor)
|
|
const totalWidth =
|
|
parseFloat(styles.width) +
|
|
parseFloat(styles.marginLeft) +
|
|
parseFloat(styles.marginRight) +
|
|
parseFloat(styles.paddingLeft) +
|
|
parseFloat(styles.paddingRight)
|
|
const totalHeight =
|
|
parseFloat(styles.height) +
|
|
parseFloat(styles.marginTop) +
|
|
parseFloat(styles.marginBottom) +
|
|
parseFloat(styles.paddingTop) +
|
|
parseFloat(styles.paddingBottom)
|
|
correctionPanel.style.width = totalWidth + 'px'
|
|
correctionPanel.style.height = totalHeight + 'px'
|
|
scrollPanel.style.height = editor.scrollHeight + 'px'
|
|
}
|
|
|
|
static isPointInRect(x, y, rect, offsetTop) {
|
|
if (!offsetTop) {
|
|
return (
|
|
x >= rect.x &&
|
|
x < rect.x + rect.width &&
|
|
y >= rect.y &&
|
|
y < rect.y + rect.height
|
|
)
|
|
} else {
|
|
return (
|
|
x >= rect.x &&
|
|
x < rect.x + rect.width &&
|
|
y >= rect.y - offsetTop &&
|
|
y < rect.y + rect.height - offsetTop
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
window.onload = () => {
|
|
// Search and prepare all our editors found in the document.
|
|
document
|
|
.querySelectorAll('.bes-online-editor')
|
|
.forEach(edit => BesEditor.register(edit))
|
|
}
|
|
|
|
window.onresize = () => {
|
|
besEditors.forEach(editor => {
|
|
editor.setCorrectionPanelSize(
|
|
editor.el,
|
|
editor.correctionPanel,
|
|
editor.scrollPanel
|
|
)
|
|
editor.children.forEach(child => {
|
|
editor.clearMistakeMarkup(child.elements)
|
|
child.matches.forEach(match => {
|
|
match.rects = editor.addMistakeMarkup(match.range, editor.scrollPanel)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
// This is popup element
|
|
class BesPopupEl extends HTMLElement {
|
|
constructor() {
|
|
super()
|
|
this.attachShadow({ mode: 'open' })
|
|
}
|
|
|
|
connectedCallback() {
|
|
this.render()
|
|
}
|
|
|
|
render() {
|
|
this.shadowRoot.innerHTML = `
|
|
<style>
|
|
:host {
|
|
position: relative;
|
|
display: inline-block;
|
|
z-index: -1
|
|
}
|
|
:host(.show){
|
|
z-index: 10;
|
|
}
|
|
.popup-text {
|
|
max-width: 160px;
|
|
color: black;
|
|
text-align: center;
|
|
padding: 8px 0;
|
|
z-index: 1;
|
|
}
|
|
.bes-popup-container {
|
|
visibility: hidden;
|
|
max-width: 300px;
|
|
background-color: rgb(241, 243, 249);
|
|
box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
|
|
border-radius: 5px;
|
|
padding: 8px;
|
|
z-index: 1;
|
|
}
|
|
.bes-toolbar {
|
|
display: flex;
|
|
justify-content: end;
|
|
padding: 5px 2px;
|
|
}
|
|
.bes-toolbar button {
|
|
margin-right: 2px;
|
|
}
|
|
.bes-text-div{
|
|
background-color: white;
|
|
padding: 10px;
|
|
border-radius: 5px;
|
|
}
|
|
.bes-replacement-btn{
|
|
margin: 5px 0;
|
|
padding: 5px;
|
|
border: none;
|
|
border-radius: 5px;
|
|
background-color: #239aff;
|
|
color: white;
|
|
cursor: pointer;
|
|
}
|
|
.bes-replacement-btn:hover{
|
|
background-color: #1976f0;
|
|
}
|
|
:host(.show) .bes-popup-container {
|
|
visibility: visible;
|
|
animation: fadeIn 1s;
|
|
}
|
|
@keyframes fadeIn {
|
|
from {opacity: 0;}
|
|
to {opacity:1 ;}
|
|
}
|
|
</style>
|
|
<div class="bes-popup-container">
|
|
<div class="bes-toolbar">
|
|
<button class="bes-close-btn">X</button>
|
|
</div>
|
|
<div class="bes-text-div">
|
|
<span class="popup-text">
|
|
</span>
|
|
<div class="bes-replacement-div">
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`
|
|
}
|
|
|
|
show(x, y) {
|
|
y = y + 20
|
|
this.style.position = 'fixed'
|
|
this.style.left = `${x}px`
|
|
this.style.top = `${y}px`
|
|
this.clear()
|
|
this.classList.add('show')
|
|
}
|
|
|
|
clear() {
|
|
const replacementDiv = this.shadowRoot.querySelector('.bes-replacement-div')
|
|
const replacements = replacementDiv.childNodes
|
|
if (!replacements.length) return
|
|
replacements.forEach(replacement => {
|
|
replacementDiv.removeChild(replacement)
|
|
})
|
|
}
|
|
|
|
hide() {
|
|
this.classList.remove('show')
|
|
}
|
|
|
|
changeText(text) {
|
|
this.shadowRoot.querySelector('.popup-text').textContent = text
|
|
}
|
|
|
|
appendReplacements(el, rect, match, replacement, editor) {
|
|
const replacementDiv = this.shadowRoot.querySelector('.bes-replacement-div')
|
|
const replacementBtn = document.createElement('button')
|
|
replacementBtn.classList.add('bes-replacement-btn')
|
|
replacementBtn.textContent = replacement
|
|
replacementBtn.classList.add('bes-replacement')
|
|
replacementBtn.addEventListener('click', () => {
|
|
BesEditor.replaceText(el, rect, match, replacement, editor)
|
|
})
|
|
replacementDiv.appendChild(replacementBtn)
|
|
}
|
|
}
|
|
|
|
customElements.define('bes-popup-el', BesPopupEl)
|