Notes/src/utils.js

export const defaultConfig = {
	engine: 'mathjax',
	outputType: 'script',
	forceOutputType: false,
	enablePreview: true
};

export function getSelectedMathModelWidget( selection ) {
	const selectedElement = selection.getSelectedElement();

	if ( selectedElement && selectedElement.is( 'mathtex' ) ) {
		return selectedElement;
	}

	return null;
}

export function renderEquation( equation, element, engine = 'katex', display = false, preview = false ) {
	if ( engine === 'mathjax' && typeof MathJax !== 'undefined' ) {
		if ( isMathJaxVersion3( MathJax.version ) ) {
			selectRenderMode( element, preview, el => {
				renderMathJax3( equation, el, display, () => {
					if ( preview ) {
						el.style.display = 'block';
						moveAndScaleElement( element, el );
					}
				} );
			} );
		} else {
			selectRenderMode( element, preview, el => {
				// Fixme: MathJax typesetting cause occasionally math processing error without asynchronous call
				// eslint-disable-next-line
				setTimeout( () => {
					renderMathJax2( equation, el, display );

					// Move and scale after rendering
					if ( preview ) {
						// eslint-disable-next-line
						MathJax.Hub.Queue( () => {
							el.style.display = 'block';
							moveAndScaleElement( element, el );
						} );
					}
				} );
			} );
		}
	} else if ( engine === 'katex' && typeof katex !== 'undefined' ) {
		selectRenderMode( element, preview, el => {
			katex.render( equation, el, {
				throwOnError: false,
				displayMode: display
			} );
			if ( preview ) {
				el.style.display = 'block';
				moveAndScaleElement( element, el );
			}
		} );
	} else if ( typeof engine === 'function' ) {
		engine( equation, element, display );
	} else {
		element.innerHTML = equation;
		// eslint-disable-next-line
		console.warn( `math-tex-typesetting-missing: Missing the mathematical typesetting engine (${engine}) for tex.` );
	}
}

function selectRenderMode( element, preview, cb ) {
	if ( preview ) {
		createPreviewElement( element, prewviewEl => {
			cb( prewviewEl );
		} );
	} else {
		cb( element );
	}
}

function renderMathJax3( equation, element, display, after ) {
	let promiseFunction = undefined;
	if ( typeof MathJax.tex2chtmlPromise !== 'undefined' ) {
		promiseFunction = MathJax.tex2chtmlPromise;
	} else if ( typeof MathJax.tex2svgPromise !== 'undefined' ) {
		promiseFunction = MathJax.tex2svgPromise;
	}

	if ( typeof promiseFunction !== 'undefined' ) {
		promiseFunction( equation, { display } ).then( node => {
			if ( element.firstChild ) {
				element.removeChild( element.firstChild );
			}
			element.appendChild( node );
			after();
		} );
	}
}

function renderMathJax2( equation, element, display ) {
	if ( display ) {
		element.innerHTML = '\\[' + equation + '\\]';
	} else {
		element.innerHTML = '\\(' + equation + '\\)';
	}
	MathJax.Hub.Queue( [ 'Typeset', MathJax.Hub, element ] ); // eslint-disable-line
}

function createPreviewElement( element, render ) {
	const prewviewEl = getPreviewElement( element );
	render( prewviewEl );
}

export function getPreviewElement( element ) {
	const elId = 'math-preview';
	let prewviewEl = document.getElementById( elId ); // eslint-disable-line
	if ( !prewviewEl ) {
		prewviewEl = document.createElement( 'div' ); // eslint-disable-line
		prewviewEl.setAttribute( 'id', elId );
		document.body.appendChild( prewviewEl ); // eslint-disable-line

		let ticking = false;

		const renderTransformation = () => {
			if ( !ticking ) {
				// eslint-disable-next-line
				window.requestAnimationFrame( () => {
					moveElement( element, prewviewEl );
					ticking = false;
				} );

				ticking = true;
			}
		};

		// Create scroll listener for following
		window.addEventListener( 'resize', renderTransformation ); // eslint-disable-line
		window.addEventListener( 'scroll', renderTransformation ); // eslint-disable-line
	}
	return prewviewEl;
}

function moveAndScaleElement( parent, child ) {
	// Move to right place
	moveElement( parent, child );

	// Scale parent element same as preview
	const domRect = child.getBoundingClientRect();
	parent.style.width = domRect.width + 'px';
	parent.style.height = domRect.height + 'px';
}

function moveElement( parent, child ) {
	const domRect = parent.getBoundingClientRect();
	const left = window.scrollX + domRect.left; // eslint-disable-line
	const top = window.scrollY + domRect.top; // eslint-disable-line
	child.style.position = 'absolute';
	child.style.left = left + 'px';
	child.style.top = top + 'px';
	child.style.zIndex = 'var(--ck-z-modal)';
	child.style.pointerEvents = 'none';
}

// Simple MathJax 3 version check
export function isMathJaxVersion3( version ) {
	return version && typeof version === 'string' && version.split( '.' ).length === 3 && version.split( '.' )[ 0 ] === '3';
}

// Check if equation has delimiters
export function hasDelimiters( text ) {
	return text.match( /^(\\\[.*?\\\]|\\\(.*?\\\))$/ );
}

// Extract delimiters and figure display mode for the model
export function extractDelimiters( equation ) {
	equation = equation.trim();

	// Remove delimiters (e.g. \( \) or \[ \])
	const hasInlineDelimiters = equation.includes( '\\(' ) && equation.includes( '\\)' );
	const hasDisplayDelimiters = equation.includes( '\\[' ) && equation.includes( '\\]' );
	if ( hasInlineDelimiters || hasDisplayDelimiters ) {
		equation = equation.substring( 2, equation.length - 2 ).trim();
	}

	return {
		equation,
		display: hasDisplayDelimiters
	};
}