/**
* Text editor - all contenteditable text-editing setup
*
* Reads (via globals):
* SFE.Context - .draftEditState
* SFE.ElementPrep - .getCleanHTML, .getContent
* SFE.OverlayManager
* SFE.PositionManager - .positionFloatingElements
* SFE.FocusManager - .createFocusManager
* SFE.handleInlineSave - set by SaveManager
* SFE.closeInPlaceEditor - set by EditorLifecycle
* SFE.startMediaEditing - set by frontend-inline-edit.js (via SFE.MediaEditor)
* SFE.MWPEditor - rich text editor class
* SFE.ManagerData - .handlers
*
* Exposes: SFE.TextEditor
* { startTextEditing, startMultiComponentEditing, refreshEditableComponents }
*/
(function() {
'use strict';
window.MWP = window.MWP || {};
window.MWP.SFE = window.MWP.SFE || {};
const SFE = window.MWP.SFE;
SFE.ManagerData = SFE.ManagerData || {};
const MWPEditor = SFE.MWPEditor;
function normalizeEditorFormatsSpec(rawFormats, depth = 0) {
if (depth > 3 || !Array.isArray(rawFormats)) {
return null;
}
const normalized = [];
rawFormats.forEach((item) => {
if (typeof item === 'string') {
const token = item.trim();
if (token) {
normalized.push(token);
}
return;
}
if (Array.isArray(item)) {
const group = normalizeEditorFormatsSpec(item, depth + 1);
if (Array.isArray(group) && group.length) {
normalized.push(group);
}
}
});
return normalized.length ? normalized : null;
}
function cloneEditorFormatsSpec(formatsSpec) {
if (!Array.isArray(formatsSpec)) return null;
return formatsSpec.map(item => (
Array.isArray(item) ? cloneEditorFormatsSpec(item) : item
));
}
function normalizeInlineFormatCapability(rawCapability) {
if (!rawCapability || typeof rawCapability !== 'object' || Array.isArray(rawCapability)) {
return null;
}
const tag = typeof rawCapability.tag === 'string'
? rawCapability.tag.trim().toLowerCase()
: '';
if (!tag) return null;
const normalizeStringArray = (rawValue) => {
if (!Array.isArray(rawValue)) return null;
const values = rawValue
.map((value) => (typeof value === 'string' ? value.trim() : ''))
.filter(Boolean);
return values.length ? values : null;
};
const normalized = { tag };
const attributes = normalizeStringArray(rawCapability.attributes);
const requiredAttributes = normalizeStringArray(rawCapability.requiredAttributes);
const allowedTargets = normalizeStringArray(rawCapability.allowedTargets);
const allowedRelTokens = normalizeStringArray(rawCapability.allowedRelTokens);
const allowedProtocols = normalizeStringArray(rawCapability.allowedProtocols);
if (attributes) normalized.attributes = attributes;
if (requiredAttributes) normalized.requiredAttributes = requiredAttributes;
if (allowedTargets) normalized.allowedTargets = allowedTargets;
if (allowedRelTokens) normalized.allowedRelTokens = allowedRelTokens;
if (allowedProtocols) normalized.allowedProtocols = allowedProtocols;
if (typeof rawCapability.allowsRelativeUrls === 'boolean') {
normalized.allowsRelativeUrls = rawCapability.allowsRelativeUrls;
}
if (typeof rawCapability.allowsAnchorLinks === 'boolean') {
normalized.allowsAnchorLinks = rawCapability.allowsAnchorLinks;
}
if (typeof rawCapability.autoProtocol === 'string' && rawCapability.autoProtocol.trim()) {
normalized.autoProtocol = rawCapability.autoProtocol.trim().toLowerCase();
}
if (typeof rawCapability.preservesUnknownRelTokens === 'boolean') {
normalized.preservesUnknownRelTokens = rawCapability.preservesUnknownRelTokens;
}
return normalized;
}
function cloneInlineFormatCapabilities(inlineFormatCapabilities) {
if (!inlineFormatCapabilities || typeof inlineFormatCapabilities !== 'object' || Array.isArray(inlineFormatCapabilities)) {
return null;
}
const cloned = {};
Object.keys(inlineFormatCapabilities).forEach((key) => {
const cleanKey = typeof key === 'string' ? key.trim() : '';
if (!cleanKey) return;
const capability = normalizeInlineFormatCapability(inlineFormatCapabilities[key]);
if (!capability) return;
cloned[cleanKey] = capability;
});
return Object.keys(cloned).length ? cloned : null;
}
function normalizeAttributeCapabilityValues(rawValues) {
if (!Array.isArray(rawValues)) return null;
const values = rawValues.filter(value => (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean' ||
value === null
));
return values.length ? values : null;
}
function normalizeAttributeCapability(rawCapability) {
if (!rawCapability || typeof rawCapability !== 'object' || Array.isArray(rawCapability)) {
return null;
}
const normalized = {};
const attribute = typeof rawCapability.attribute === 'string'
? rawCapability.attribute.trim()
: '';
const attributes = Array.isArray(rawCapability.attributes)
? rawCapability.attributes
.map(value => (typeof value === 'string' ? value.trim() : ''))
.filter(Boolean)
: null;
if (attribute) {
normalized.attribute = attribute;
} else if (attributes && attributes.length) {
normalized.attributes = attributes;
} else {
return null;
}
const values = normalizeAttributeCapabilityValues(rawCapability.values);
if (values) {
normalized.values = values;
}
if (
Object.prototype.hasOwnProperty.call(rawCapability, 'unsetValue') &&
(
typeof rawCapability.unsetValue === 'string' ||
typeof rawCapability.unsetValue === 'number' ||
typeof rawCapability.unsetValue === 'boolean' ||
rawCapability.unsetValue === null
)
) {
normalized.unsetValue = rawCapability.unsetValue;
}
return normalized;
}
function cloneAttributeCapabilities(attributeCapabilities) {
if (!attributeCapabilities || typeof attributeCapabilities !== 'object' || Array.isArray(attributeCapabilities)) {
return null;
}
const cloned = {};
Object.keys(attributeCapabilities).forEach((key) => {
const cleanKey = typeof key === 'string' ? key.trim() : '';
if (!cleanKey) return;
const capability = normalizeAttributeCapability(attributeCapabilities[key]);
if (!capability) return;
cloned[cleanKey] = { ...capability };
if (Array.isArray(capability.attributes)) {
cloned[cleanKey].attributes = [ ...capability.attributes ];
}
if (Array.isArray(capability.values)) {
cloned[cleanKey].values = [ ...capability.values ];
}
});
return Object.keys(cloned).length ? cloned : null;
}
function normalizeEditorOperationValues(rawValues) {
if (!Array.isArray(rawValues)) return null;
const values = rawValues.filter(value => (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean' ||
value === null
));
return values.length ? values : null;
}
function normalizeEditorOperationStringArray(rawValues) {
if (!Array.isArray(rawValues)) return null;
const values = rawValues
.map(value => (typeof value === 'string' ? value.trim() : ''))
.filter(Boolean);
return values.length ? values : null;
}
function normalizeEditorOperation(rawOperation) {
if (!rawOperation || typeof rawOperation !== 'object' || Array.isArray(rawOperation)) {
return null;
}
const id = typeof rawOperation.id === 'string' ? rawOperation.id.trim() : '';
const kind = typeof rawOperation.kind === 'string' ? rawOperation.kind.trim() : '';
const component = typeof rawOperation.component === 'string' ? rawOperation.component.trim() : '';
if (!id || !kind || !component) {
return null;
}
const normalized = { id, kind, component };
const attribute = typeof rawOperation.attribute === 'string' ? rawOperation.attribute.trim() : '';
const format = typeof rawOperation.format === 'string' ? rawOperation.format.trim() : '';
const attributes = normalizeEditorOperationStringArray(rawOperation.attributes);
const formats = normalizeEditorOperationStringArray(rawOperation.formats);
const targetModes = normalizeEditorOperationStringArray(rawOperation.targetModes);
const values = normalizeEditorOperationValues(rawOperation.values);
if (attribute) {
normalized.attribute = attribute;
}
if (attributes) {
normalized.attributes = attributes;
}
if (format) {
normalized.format = format;
}
if (formats) {
normalized.formats = formats;
}
if (targetModes) {
normalized.targetModes = targetModes;
}
if (values) {
normalized.values = values;
}
if (Object.prototype.hasOwnProperty.call(rawOperation, 'unsetValue')) {
normalized.unsetValue = rawOperation.unsetValue;
}
if (typeof rawOperation.preserveInlineFormatting === 'boolean') {
normalized.preserveInlineFormatting = rawOperation.preserveInlineFormatting;
}
if (typeof rawOperation.preserveUnchangedText === 'boolean') {
normalized.preserveUnchangedText = rawOperation.preserveUnchangedText;
}
if (typeof rawOperation.preserveUnspecifiedAttributes === 'boolean') {
normalized.preserveUnspecifiedAttributes = rawOperation.preserveUnspecifiedAttributes;
}
if (typeof rawOperation.mergeRelTokens === 'boolean') {
normalized.mergeRelTokens = rawOperation.mergeRelTokens;
}
return normalized;
}
function cloneEditorOperations(rawOperations) {
if (!Array.isArray(rawOperations)) return null;
const normalized = rawOperations
.map(normalizeEditorOperation)
.filter(Boolean);
return normalized.length ? normalized : null;
}
/**
* Resolve the concrete toolbar format config for one text component.
*
* @param {HTMLElement|null} element Active editable element.
* @param {Object} runtimeOptions Normalized component editor options.
* @returns {Array} Concrete toolbar format definitions.
*/
function resolveComponentFormats(element, runtimeOptions) {
const toolbarManager = SFE.ToolbarManager || null;
if (toolbarManager && typeof toolbarManager.resolveFormats === 'function') {
return toolbarManager.resolveFormats(runtimeOptions, element);
}
return [];
}
/**
* Execute one list indentation action for the active rich-text editor host.
*
* @param {Object|null} editor Active rich-text editor host.
* @param {string} action Tab-mode action: `indent` or `outdent`.
* @returns {void}
*/
function executeListTabAction(editor, action) {
if (!editor || typeof editor.executeListStructureOperation !== 'function') {
return;
}
const operationKind = action === 'indent'
? 'indent_list_item'
: action === 'outdent'
? 'outdent_list_item'
: '';
if (!operationKind) {
return;
}
editor.executeListStructureOperation({
kind: operationKind,
});
}
/**
* Place caret from click coordinates when available, otherwise at element end.
*/
function placeCaretInEditableElement(editableElement, clickEvent) {
if (!editableElement) return;
editableElement.focus();
setTimeout(() => {
// Guard: element may have been detached from the document between the
// time this setTimeout was scheduled and when it fires (e.g. during
// rapid component switches or editor teardown). Calling addRange() on
// a range whose boundary nodes are not in the document throws:
// "addRange(): The given range isn't in document."
if (!document.body.contains(editableElement)) return;
const selection = window.getSelection();
const range = document.createRange();
const placeholderApi = SFE.RichTextPlaceholder || null;
const placeholderCaret = (
placeholderApi &&
typeof placeholderApi.getCaretTarget === 'function'
)
? placeholderApi.getCaretTarget(editableElement)
: null;
if (placeholderCaret?.node) {
// Guard placeholder node as well - it may reference a node inside
// a ghost/placeholder element that was removed between ticks.
if (!document.body.contains(placeholderCaret.node)) return;
range.setStart(placeholderCaret.node, placeholderCaret.offset);
range.collapse(true);
selection.removeAllRanges();
selection.addRange(range);
return;
}
if (clickEvent && clickEvent.clientX !== undefined && clickEvent.clientY !== undefined) {
try {
let clickRange = null;
if (document.caretPositionFromPoint) {
const pos = document.caretPositionFromPoint(clickEvent.clientX, clickEvent.clientY);
if (pos) {
clickRange = document.createRange();
clickRange.setStart(pos.offsetNode, pos.offset);
clickRange.collapse(true);
}
} else if (document.caretRangeFromPoint) {
clickRange = document.caretRangeFromPoint(clickEvent.clientX, clickEvent.clientY);
}
if (clickRange && editableElement.contains(clickRange.startContainer)) {
selection.removeAllRanges();
selection.addRange(clickRange);
return;
}
} catch (e) { /* ignore */ }
}
range.selectNodeContents(editableElement);
range.collapse(false);
selection.removeAllRanges();
selection.addRange(range);
}, 0);
}
/**
* Find the first selector match that belongs to this block root (not a nested block).
*/
function findScopedComponentElement(rootElement, selector) {
if (!rootElement || !selector) return null;
if (rootElement.matches(selector)) {
const owner = rootElement.closest('[data-mwp-sfe-uuid]');
if (!owner || owner === rootElement) return rootElement;
}
const matches = rootElement.querySelectorAll(selector);
for (const candidate of matches) {
const owner = candidate.closest('[data-mwp-sfe-uuid]');
if (!owner || owner === rootElement) {
return candidate;
}
}
return null;
}
function getEditableComponentFromTarget(components, target) {
if (!target) return null;
const targetEl = target.nodeType === Node.ELEMENT_NODE ? target : target.parentElement;
if (!targetEl) return null;
const distanceToAncestor = (descendant, ancestor) => {
let steps = 0;
let node = descendant;
while (node && node !== ancestor) {
node = node.parentElement;
steps++;
}
return node === ancestor ? steps : null;
};
let bestComponent = null;
let bestScore = Number.POSITIVE_INFINITY;
components.forEach(component => {
if (!component?.element) return;
let score = null;
// Exact target match has highest priority.
if (component.element === targetEl) {
score = 0;
} else {
// Prefer the closest containing component when multiple components overlap.
const containsDistance = distanceToAncestor(targetEl, component.element);
if (containsDistance !== null) {
score = containsDistance;
} else if (isFileComponent(component) && targetEl.contains(component.element)) {
// Fallback for file components when clicking a wrapper around the media element.
const wrapperDistance = distanceToAncestor(component.element, targetEl);
if (wrapperDistance !== null) {
score = 100 + wrapperDistance;
}
}
}
if (score !== null && score < bestScore) {
bestScore = score;
bestComponent = component;
}
});
return bestComponent;
}
function resolveInitialEditableComponent(components, clickEvent, preferredComponentId = '') {
const normalizedPreferredComponentId = String(preferredComponentId || '').trim();
if (normalizedPreferredComponentId) {
const preferredComponent = components.find(component => component?.id === normalizedPreferredComponentId);
if (preferredComponent) {
return preferredComponent;
}
}
const fromClick = getEditableComponentFromTarget(components, clickEvent?.target || null);
if (fromClick) return fromClick;
return components.find(component => component.default) || components[0] || null;
}
function normalizeComponentEditorOptions(rawEditorOptions) {
if (!rawEditorOptions || typeof rawEditorOptions !== 'object') {
return {};
}
const normalized = {};
if (typeof rawEditorOptions.enterMode === 'string') {
const mode = rawEditorOptions.enterMode.trim().toLowerCase();
if (mode === 'auto' || mode === 'always' || mode === 'never' || mode === 'linebreak') {
normalized.enterMode = mode;
}
}
if (typeof rawEditorOptions.linkUIMode === 'string') {
const mode = rawEditorOptions.linkUIMode.trim().toLowerCase();
if (mode === 'auto' || mode === 'manual') {
normalized.linkUIMode = mode;
}
}
if (rawEditorOptions.tabMode && typeof rawEditorOptions.tabMode === 'object') {
const tabMode = {};
const tabAction = typeof rawEditorOptions.tabMode.tab === 'string'
? rawEditorOptions.tabMode.tab.trim()
: '';
const shiftTabAction = typeof rawEditorOptions.tabMode.shiftTab === 'string'
? rawEditorOptions.tabMode.shiftTab.trim()
: '';
const isValidTabAction = (action) => (
action === 'none' ||
action === 'indent' ||
action === 'outdent' ||
action === 'nextComponent' ||
action === 'previousComponent'
);
if (isValidTabAction(tabAction)) {
tabMode.tab = tabAction;
}
if (isValidTabAction(shiftTabAction)) {
tabMode.shiftTab = shiftTabAction;
}
if (Object.keys(tabMode).length) {
normalized.tabMode = tabMode;
}
}
if (rawEditorOptions.options && typeof rawEditorOptions.options === 'object') {
const options = {};
if (rawEditorOptions.options.preserveNewlines === true) {
options.preserveNewlines = true;
}
if (rawEditorOptions.options.newlinesToBR === true) {
options.newlinesToBR = true;
}
if (Object.keys(options).length) {
normalized.options = options;
}
}
if (rawEditorOptions.formatTargets && typeof rawEditorOptions.formatTargets === 'object') {
const targets = {};
Object.keys(rawEditorOptions.formatTargets).forEach((key) => {
const cleanKey = typeof key === 'string' ? key.trim() : '';
const value = rawEditorOptions.formatTargets[key];
const cleanValue = typeof value === 'string' ? value.trim() : '';
if (!cleanKey || !cleanValue) return;
targets[cleanKey] = cleanValue;
});
if (Object.keys(targets).length) {
normalized.formatTargets = targets;
}
}
const formatsSpec = normalizeEditorFormatsSpec(rawEditorOptions.formats);
if (formatsSpec) {
normalized.formats = formatsSpec;
}
const inlineFormatCapabilities = cloneInlineFormatCapabilities(rawEditorOptions.inlineFormatCapabilities);
if (inlineFormatCapabilities) {
normalized.inlineFormatCapabilities = inlineFormatCapabilities;
}
const attributeCapabilities = cloneAttributeCapabilities(rawEditorOptions.attributeCapabilities);
if (attributeCapabilities) {
normalized.attributeCapabilities = attributeCapabilities;
}
const operations = cloneEditorOperations(rawEditorOptions.operations);
if (operations) {
normalized.operations = operations;
}
return normalized;
}
function normalizeComponentPlaceholder(rawPlaceholder) {
if (typeof rawPlaceholder !== 'string') {
return '';
}
return rawPlaceholder.trim();
}
/**
* Normalize the schema media descriptor attached to a file component.
*
* @param {object|null} component Editable component definition.
* @param {string} id Normalized component id.
* @param {string} selector Normalized component selector.
* @param {object|null} target Normalized schema target definition.
* @returns {object|null} Normalized schema media descriptor, or null when invalid.
*/
function normalizeSchemaMediaDescriptor(component, id, selector, target) {
const MediaHelper = SFE.MediaHelper || null;
const rawDescriptor = component?.mediaDescriptor && typeof component.mediaDescriptor === 'object'
? component.mediaDescriptor
: null;
const descriptor = rawDescriptor || {
componentId: id,
scopeSelector: selector,
targetSelector: target?.selector || '',
attribute: target?.attribute || '',
mediaType: target?.mediaType || '',
};
if (!MediaHelper?.isSchemaMediaDescriptor?.(descriptor)) {
return null;
}
return {
componentId: typeof descriptor.componentId === 'string' && descriptor.componentId.trim()
? descriptor.componentId.trim()
: id,
scopeSelector: typeof descriptor.scopeSelector === 'string' && descriptor.scopeSelector.trim()
? descriptor.scopeSelector.trim()
: selector,
targetSelector: descriptor.targetSelector.trim(),
attribute: descriptor.attribute.trim().toLowerCase(),
mediaType: descriptor.mediaType.trim().toLowerCase(),
};
}
/**
* Collect normalized editable schema components for the active block root.
*
* @param {HTMLElement} rootElement Active block root element.
* @param {object} handler Active schema-backed handler.
* @returns {Array