/**
* Stable frontend runtime PublicApi implementation.
*
* Exposes: SFE.PublicApi
* {
* getApiInfo, on, off, isEditorOpen, getActiveEditor,
* applyActiveMediaSelection, getPageContext, getRestContext, setRestNonce,
* getElementByUuid, getUuidForElement, getBlockSnapshot, getEditableBlocks,
* resolveRuntime,
* resolveEditingRuntime, getEditableComponents, getListStructure,
* getDefaultComponent, getMediaDescriptor, getMediaContext,
* isMediaEditable, openEditor, closeEditor, applyTextComponentOperations,
* applyMediaComponentOperations,
* applyBlockAttributeOperations,
* applyListOperations, applyStructuredEdit, stageBlockState,
* clearStagedBlockState, refreshBlock, getDirtyBlocks, hasDirtyBlocks,
* isBatchSessionActive, resetDirtyBlocks
* }
*
* Keeps mutable runtime internals private while exposing the documented browser
* integration surface for external consumers such as ABE.
*/
(function() {
'use strict';
window.MWP = window.MWP || {};
window.MWP.SFE = window.MWP.SFE || {};
const SFE = window.MWP.SFE;
SFE.ManagerData = SFE.ManagerData || {};
const PublicApi = SFE.PublicApi || {};
const bridge = SFE.PublicApiBridge || null;
if (!bridge) {
return;
}
/**
* Resolve the shared runtime context object.
*
* @returns {Object} Shared FrontEdit context.
*/
function getContext() {
return SFE.Context || {};
}
/**
* Resolve the localized bootstrap payload.
*
* @returns {Object} Localized manager data.
*/
function getManagerData() {
return SFE.ManagerData || {};
}
/**
* Normalize one candidate REST nonce.
*
* @param {*} nonce Candidate nonce value.
* @returns {string} Trimmed nonce or an empty string.
*/
function normalizeRestNonce(nonce) {
return String(nonce || '').trim();
}
/**
* Return the live block element for one UUID.
*
* @param {string} uuid Block UUID.
* @returns {Element|null} Matching element.
*/
function getElementByUuid(uuid) {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || typeof document.querySelector !== 'function') {
return null;
}
try {
return document.querySelector(`[data-mwp-sfe-uuid="${CSS.escape(normalizedUuid)}"]`);
} catch (error) {
return document.querySelector(`[data-mwp-sfe-uuid="${normalizedUuid.replace(/"/g, '\\"')}"]`);
}
}
/**
* Resolve one UUID from a supplied element or nested child.
*
* @param {Element|null} element Candidate DOM node.
* @returns {string} Block UUID or an empty string.
*/
function getUuidForElement(element) {
if (!(element instanceof Element)) {
return '';
}
const candidate = element.closest('[data-mwp-sfe-uuid]');
return candidate instanceof Element
? String(candidate.getAttribute('data-mwp-sfe-uuid') || '').trim()
: '';
}
/**
* Resolve one uuid-map entry from the shared context.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} UUID map entry.
*/
function getUuidEntry(uuid) {
const context = getContext();
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || !context.uuidMap || !context.uuidMap[normalizedUuid]) {
return null;
}
return context.uuidMap[normalizedUuid];
}
/**
* Resolve one edit-capable handler for the supplied target.
*
* @param {Object} options Resolution options.
* @returns {Object|null} Edit handler when supported.
*/
function resolveEditHandler(options = {}) {
const element = options.element instanceof Element ? options.element : null;
const preferredHandlerId = String(options.handlerId || '').trim();
const handlers = Array.isArray(element?._mwpSfeHandlers)
? element._mwpSfeHandlers
: [];
if (preferredHandlerId) {
const exact = handlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
));
if (exact) {
return exact;
}
}
const fromElement = handlers.find(handler => handler && handler.capability === 'edit') || null;
if (fromElement) {
return fromElement;
}
const uuidEntry = getUuidEntry(options.uuid);
const managerData = getManagerData();
const registeredHandlers = Array.isArray(managerData.handlers) ? managerData.handlers : [];
const handlerIds = Array.isArray(uuidEntry?.handlers) ? uuidEntry.handlers : [];
if (preferredHandlerId) {
return registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
)) || null;
}
for (let index = 0; index < handlerIds.length; index++) {
const handlerId = String(handlerIds[index] || '').trim();
const match = registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === handlerId
));
if (match) {
return match;
}
}
return null;
}
/**
* Resolve the current block-state payload used for schema hydration.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} Block-state payload when available.
*/
function resolveBlockState(uuid) {
const batchManager = SFE.BatchEditManager || null;
if (
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive() &&
typeof batchManager.getBlockStateForUuid === 'function'
) {
return batchManager.getBlockStateForUuid(uuid);
}
return null;
}
/**
* Resolve the schema runtime bundle for one target block.
*
* @param {Object} options Runtime resolution options.
* @returns {Object|null} Schema runtime bundle.
*/
function resolveRuntimeBundle(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const schemaRuntime = SFE.SchemaRuntime || null;
if (!uuid || !(element instanceof Element) || !handler || !schemaRuntime || typeof schemaRuntime.resolveForEditing !== 'function') {
return null;
}
try {
const blockState = options.blockState && typeof options.blockState === 'object'
? options.blockState
: resolveBlockState(uuid);
const attributeChanges = options.attributeChanges && typeof options.attributeChanges === 'object'
? options.attributeChanges
: undefined;
const resolved = schemaRuntime.resolveForEditing(element, handler, {
blockState,
attributeChanges,
});
if (!resolved || !resolved.runtimeHandler || !resolved.runtime) {
return null;
}
return {
uuid,
element,
handler: resolved.runtimeHandler,
runtime: resolved.runtime,
schema: resolved.schema || null,
};
} catch (error) {
console.warn('FrontEdit: PublicApi resolveRuntime failed', error);
return null;
}
}
/**
* Build one detailed editable-component snapshot from a schema runtime entry.
*
* @param {Object|null} editableComponent Runtime editable component.
* @param {Object|null} componentMeta Additional component metadata.
* @returns {Object|null} Detailed component snapshot.
*/
function buildEditingRuntimeComponentDetail(editableComponent, componentMeta = null) {
const snapshot = buildEditableComponentSnapshot(editableComponent);
if (!snapshot) {
return null;
}
const meta = componentMeta && typeof componentMeta === 'object' ? componentMeta : {};
snapshot.element = editableComponent?.element instanceof Element
? editableComponent.element
: (meta.element instanceof Element ? meta.element : null);
const bindings = Array.isArray(meta.bindings)
? bridge.clonePlainData(meta.bindings)
: [];
if (bindings.length) {
snapshot.bindings = bindings;
}
const target = meta.target && typeof meta.target === 'object'
? bridge.clonePlainData(meta.target)
: (snapshot.target || null);
if (target) {
snapshot.target = target;
}
const editorOptions = editableComponent?.editorOptions && typeof editableComponent.editorOptions === 'object'
? bridge.clonePlainData(editableComponent.editorOptions)
: (meta.editorOptions && typeof meta.editorOptions === 'object'
? bridge.clonePlainData(meta.editorOptions)
: null);
if (editorOptions) {
snapshot.editorOptions = editorOptions;
snapshot.editor = bridge.clonePlainData(editorOptions);
}
return snapshot;
}
/**
* Build one detailed schema-resolved editing runtime snapshot.
*
* This exposes the same resolved component metadata FrontEdit uses for editing
* while keeping handler resolution and schema runtime execution owned by FrontEdit.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Detailed editing runtime snapshot.
*/
function buildResolvedEditingRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const runtimeComponentsById = bundle.runtime.componentsById && typeof bundle.runtime.componentsById === 'object'
? bundle.runtime.componentsById
: {};
const componentDetails = [];
const componentsById = {};
(Array.isArray(bundle.runtime.editableComponents) ? bundle.runtime.editableComponents : []).forEach(component => {
const componentId = String(component?.id || '').trim();
const detail = buildEditingRuntimeComponentDetail(component, componentId ? runtimeComponentsById[componentId] : null);
if (!detail || !componentId) {
return;
}
componentDetails.push(detail);
componentsById[componentId] = detail;
});
Object.keys(runtimeComponentsById).forEach(componentId => {
if (componentsById[componentId]) {
return;
}
const detail = buildEditingRuntimeComponentDetail(runtimeComponentsById[componentId], runtimeComponentsById[componentId]);
if (!detail) {
return;
}
detail.id = componentId;
componentDetails.push(detail);
componentsById[componentId] = detail;
});
const mediaComponentId = String(bundle.runtime?.mediaComponent?.id || '').trim();
const mediaComponent = mediaComponentId && componentsById[mediaComponentId]
? componentsById[mediaComponentId]
: null;
return {
uuid: bundle.uuid,
element: bundle.element instanceof Element ? bundle.element : null,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
runtimeHandler: {
id: String(bundle.handler.id || '').trim(),
},
runtime: {
blockName: String(bundle.runtime.blockName || '').trim(),
editableComponents: componentDetails,
componentsById,
mediaComponent,
},
schema: {
handlerId: String(bundle.schema?.handlerId || bundle.handler.id || '').trim(),
},
};
}
/**
* Return a plain snapshot of one editable component.
*
* @param {Object|null} component Runtime component.
* @returns {Object|null} Public component snapshot.
*/
function buildEditableComponentSnapshot(component) {
if (!component || typeof component !== 'object') {
return null;
}
const snapshot = {
id: String(component.id || '').trim(),
label: String(component.label || component.id || '').trim(),
type: String(component.type || '').trim().toLowerCase(),
selector: String(component.selector || '').trim(),
default: !!component.default,
};
if (!snapshot.id || !snapshot.type) {
return null;
}
if (component.required === true) {
snapshot.required = true;
}
if (typeof component.placeholder === 'string' && component.placeholder.trim()) {
snapshot.placeholder = component.placeholder;
}
if (component.target && typeof component.target === 'object') {
snapshot.target = bridge.clonePlainData(component.target);
}
if (component.mediaDescriptor && typeof component.mediaDescriptor === 'object') {
snapshot.mediaDescriptor = bridge.clonePlainData(component.mediaDescriptor);
}
if (component.editorOptions && typeof component.editorOptions === 'object') {
snapshot.editor = bridge.clonePlainData(component.editorOptions);
}
return snapshot;
}
/**
* Resolve the public runtime mode label.
*
* @param {Object|null} runtime Schema runtime.
* @returns {string} Runtime mode label.
*/
function resolvePublicRuntimeMode(runtime) {
const components = Array.isArray(runtime?.editableComponents) ? runtime.editableComponents : [];
const hasText = components.some(component => String(component?.type || '').trim().toLowerCase() !== 'file');
const hasFile = components.some(component => String(component?.type || '').trim().toLowerCase() === 'file');
if (hasText && hasFile) {
return 'mixed';
}
if (hasFile) {
return 'file';
}
return 'text';
}
/**
* Build one public runtime snapshot from a schema bundle.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Public runtime snapshot.
*/
function buildResolvedRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const components = Array.isArray(bundle.runtime.editableComponents)
? bundle.runtime.editableComponents.map(buildEditableComponentSnapshot).filter(Boolean)
: [];
const defaultComponent = components.find(component => component.default) || components[0] || null;
return {
uuid: bundle.uuid,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
mode: resolvePublicRuntimeMode(bundle.runtime),
defaultComponentId: defaultComponent ? defaultComponent.id : '',
components,
};
}
/**
* Resolve a public media descriptor for one target block.
*
* @param {Object} options Media resolution options.
* @returns {Object|null} Media descriptor snapshot.
*/
function resolveMediaDescriptor(options = {}) {
const runtime = resolveRuntimeBundle(options);
if (!runtime) {
return null;
}
const componentId = String(options.componentId || '').trim();
const components = Array.isArray(runtime.runtime.editableComponents) ? runtime.runtime.editableComponents : [];
const selected = componentId
? components.find(component => component && component.id === componentId)
: (
(runtime.runtime.mediaComponent && typeof runtime.runtime.mediaComponent === 'object'
? runtime.runtime.mediaComponent
: components.find(component => String(component?.type || '').trim().toLowerCase() === 'file')
) || null
);
if (!selected || !selected.mediaDescriptor || typeof selected.mediaDescriptor !== 'object') {
return null;
}
return bridge.clonePlainData(selected.mediaDescriptor);
}
/**
* Build one stable block snapshot.
*
* @param {string} uuid Target UUID.
* @returns {Object|null} Block snapshot.
*/
function buildBlockSnapshot(uuid) {
const normalizedUuid = String(uuid || '').trim();
const entry = getUuidEntry(normalizedUuid);
if (!normalizedUuid || !entry) {
return null;
}
return {
uuid: normalizedUuid,
blockName: String(entry.blockName || '').trim(),
handlerIds: Array.isArray(entry.handlers) ? entry.handlers.slice() : [],
isPending: !!entry.is_pending,
pendingInfo: entry.pending_info ? bridge.clonePlainData(entry.pending_info) : null,
elementPresent: !!getElementByUuid(normalizedUuid),
};
}
/**
* Return stable discovery snapshots for every editable block on this page.
*
* @returns {Array} Editable block snapshots in FrontEdit UUID-map order.
*/
function getEditableBlocks() {
const context = getContext();
const uuidMap = context.uuidMap && typeof context.uuidMap === 'object'
? context.uuidMap
: {};
return Object.keys(uuidMap)
.map(uuid => {
const snapshot = buildBlockSnapshot(uuid);
if (!snapshot) {
return null;
}
const element = getElementByUuid(uuid);
return {
...snapshot,
contentText: element instanceof Element
? String(element.textContent || '').replace(/\s+/g, ' ').trim()
: '',
};
})
.filter(Boolean);
}
/**
* Determine whether a block currently has tracked unsaved changes.
*
* @param {string} uuid Block UUID.
* @returns {boolean} Whether the block is dirty.
*/
function isDirtyUuid(uuid) {
const batchManager = SFE.BatchEditManager || null;
return !!(
uuid &&
batchManager &&
batchManager.dirtyBlocks instanceof Map &&
batchManager.dirtyBlocks.has(uuid)
);
}
/**
* Build one public editor snapshot from a live editor state object.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object|null} Stable editor snapshot.
*/
function buildEditorSnapshot(editorState) {
if (!editorState || !editorState.uuid) {
return null;
}
const draftEditState = getContext().draftEditState;
const isDraftSession = !!(
draftEditState &&
draftEditState.draftElement &&
draftEditState.draftElement === editorState.element
);
const activeComponentId = String(
editorState.activeComponentId
|| editorState.activeEditableComponent?.id
|| ''
).trim();
const activeComponentType = String(
editorState._mwpActiveComponentType
|| editorState.activeEditableComponent?.type
|| (editorState.isMediaEditor ? 'file' : 'text')
).trim().toLowerCase();
const activeEditorHost = resolveActiveEditorHost(editorState);
return {
uuid: String(editorState.uuid || '').trim(),
handlerId: String(editorState._mwpSchemaHandlerId || editorState.handler?.id || '').trim(),
mode: String(editorState.requestedMode || (isDraftSession ? 'draft' : 'edit')).trim() || 'edit',
blockName: String(editorState.blockName || editorState.blockState?.blockName || '').trim(),
isOpen: true,
componentType: activeComponentType || 'text',
componentId: activeComponentId,
saveStrategy: String(editorState.saveStrategy || 'single').trim() || 'single',
hasMediaSession: typeof activeEditorHost?.applyMediaSelection === 'function',
isDirty: isDirtyUuid(editorState.uuid),
isDraftSession,
isBatchSession: !!(
editorState.saveStrategy === 'batch' &&
SFE.BatchEditManager &&
typeof SFE.BatchEditManager.isSessionActive === 'function' &&
SFE.BatchEditManager.isSessionActive()
),
};
}
/**
* Switch the active editable component inside one open editor session.
*
* @param {Object} editorState Active editor state.
* @param {string} componentId Target component identifier.
* @returns {boolean} Whether the switch succeeded.
*/
function activateEditorComponent(editorState, componentId) {
if (!editorState || !componentId) {
return false;
}
if (SFE.TextEditor && typeof SFE.TextEditor.activateEditableComponentById === 'function') {
return !!SFE.TextEditor.activateEditableComponentById(editorState, componentId);
}
return false;
}
/**
* Open one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Open-editor options.
* @returns {Promise} Editor snapshot after opening.
*/
async function openEditor(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const componentId = String(options.componentId || '').trim();
if (!uuid || !(element instanceof Element) || !handler || typeof SFE.startEditing !== 'function') {
return null;
}
const activeEditor = getContext().activeEditor || null;
if (activeEditor && String(activeEditor.uuid || '').trim() === uuid) {
if (componentId) {
activateEditorComponent(activeEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || activeEditor);
}
if (activeEditor && typeof SFE.closeInPlaceEditor === 'function') {
SFE.closeInPlaceEditor(activeEditor, true, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
});
}
await Promise.resolve(
SFE.startEditing(
element,
handler,
uuid,
null,
false,
String(options.mode || 'edit').trim() || 'edit',
{
initialComponentId: componentId,
source: String(options.source || 'external').trim() || 'external',
originalSnapshots: options.originalSnapshots && typeof options.originalSnapshots === 'object'
? {
restoreOuterHTML: String(options.originalSnapshots.restoreOuterHTML || '').trim(),
cleanOuterHTML: String(options.originalSnapshots.cleanOuterHTML || '').trim(),
}
: null,
}
)
);
const openedEditor = getContext().activeEditor || null;
if (openedEditor && componentId) {
activateEditorComponent(openedEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || openedEditor);
}
/**
* Close one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Close-editor options.
* @returns {boolean} Whether a close was attempted.
*/
function closeEditor(options = {}) {
const activeEditor = getContext().activeEditor || null;
if (!activeEditor || typeof SFE.closeInPlaceEditor !== 'function') {
return false;
}
const targetUuid = String(options.uuid || '').trim();
if (targetUuid && String(activeEditor.uuid || '').trim() !== targetUuid) {
return false;
}
return SFE.closeInPlaceEditor(activeEditor, options.restoreOriginal !== false, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
}) !== false;
}
/**
* Resolve the active editor state for one target block UUID.
*
* Schema-backed editor operations intentionally require a live open editor so
* the DOM mutation stays inside the same save/history session FrontEdit owns.
*
* @param {Object} options Editor-operation options.
* @returns {Object|null} Active editor state.
*/
function resolveActiveEditorState(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
return resolveActiveEditorHost(activeEditor) ? activeEditor : null;
}
function resolveActiveEditorHost(editorState) {
return SFE.SchemaEditorHost?.resolveActiveEditorHost?.(editorState) || null;
}
/**
* Resolve the session-owned history API for one active editor host.
*
* External runtime mutations should commit through the same shared block
* session contract used internally instead of reaching into ad hoc
* editor-state history fields.
*
* @param {Object|null} editorHost Active schema editor host.
* @returns {Object|null} Session history API, or null when unavailable.
*/
function getSessionHistoryApiForHost(editorHost) {
if (editorHost?.historyApi && typeof editorHost.historyApi === 'object') {
return editorHost.historyApi;
}
if (typeof editorHost?.getSessionHistoryApi === 'function') {
return editorHost.getSessionHistoryApi();
}
const blockEditSession = editorHost?.blockEditSession || null;
if (!blockEditSession || typeof blockEditSession.getHistoryApi !== 'function') {
return null;
}
return blockEditSession.getHistoryApi(
String(editorHost?.blockEditSessionScopeId || '').trim() || 'text'
);
}
/**
* Refresh one active editor state after a schema-driven DOM mutation.
*
* @param {Object} editorState Active editor state.
* @returns {void}
*/
function syncActiveEditorState(editorState) {
if (!editorState?.handler) {
return;
}
const editorHost = resolveActiveEditorHost(editorState);
const blockRootElement = (
editorHost &&
typeof editorHost.getBlockRootElement === 'function'
)
? editorHost.getBlockRootElement()
: null;
if (blockRootElement && blockRootElement !== editorState.element) {
// The active schema host element can be one editable component (for
// example, one table cell), while block-session history and restore must
// keep targeting the outer block root. Rebasing `editorState.element` to
// the component host corrupts undo/redo by replaying full block markup
// into that component instead of the block wrapper.
editorState.element = blockRootElement;
}
if (!editorState.element) {
return;
}
const schemaRuntime = SFE.SchemaRuntime || null;
if (
schemaRuntime &&
typeof schemaRuntime.syncPlaceholders === 'function'
) {
schemaRuntime.syncPlaceholders(editorState.element, editorState.handler, {
blockAttributes: editorState.blockState?.attrs || null,
attributeChanges: editorState.attributeChanges || null,
});
}
if (
SFE.TextEditor &&
typeof SFE.TextEditor.refreshEditableComponents === 'function'
) {
SFE.TextEditor.refreshEditableComponents(editorState);
}
}
/**
* Build one component map for the active schema editor state.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object} Editable components keyed by ID.
*/
function getActiveEditorComponentMap(editorState) {
if (!editorState || !Array.isArray(editorState.editableComponents)) {
return {};
}
return editorState.editableComponents.reduce((map, component) => {
const componentId = String(component?.id || '').trim();
if (!componentId || !component?.element) {
return map;
}
map[componentId] = component;
return map;
}, {});
}
/**
* Return the lowercase host tag name for one candidate component element.
*
* @param {Element|null} hostElement Candidate host element.
* @returns {string} Lowercase host tag name.
*/
function getHostElementTagName(hostElement) {
return hostElement && hostElement.tagName
? String(hostElement.tagName || '').trim().toLowerCase()
: '';
}
/**
* Build one inline format wrapper for a structured run token.
*
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {string} formatToken Format token.
* @param {Object|null} formatAttributes Optional format attributes.
* @returns {HTMLElement|null} Wrapper element.
*/
function buildStructuredFormatWrapper(inlineCapabilities, formatToken, formatAttributes = null) {
const tagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!tagName) {
return null;
}
const element = document.createElement(tagName);
if (tagName === 'a' && formatAttributes && typeof formatAttributes === 'object') {
const href = String(formatAttributes.href || '').trim();
if (href) {
element.setAttribute('href', href);
}
const target = String(formatAttributes.target || '').trim();
if (target) {
element.setAttribute('target', target);
}
const rel = String(formatAttributes.rel || '').trim();
if (rel) {
element.setAttribute('rel', rel);
}
}
return element;
}
/**
* Hoist same-tag inline format attributes onto the host component element.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Element|null} hostElement Live host element.
* @returns {{runs: Array, hostAttributes: Object}} Hoisted run data.
*/
function hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement = null) {
const hostTagName = getHostElementTagName(hostElement);
if (!hostTagName) {
return {
runs: Array.isArray(runs) ? runs : [],
hostAttributes: {},
};
}
const hostAttributes = {};
const normalizedRuns = (Array.isArray(runs) ? runs : []).map(run => {
const formats = Array.isArray(run?.formats) ? run.formats : [];
const formatAttributes = run?.formatAttributes && typeof run.formatAttributes === 'object'
? { ...run.formatAttributes }
: {};
const nextFormats = [];
formats.forEach(formatToken => {
const formatTagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!formatTagName || formatTagName !== hostTagName) {
nextFormats.push(formatToken);
return;
}
const attributes = formatAttributes?.[formatToken];
if (attributes && typeof attributes === 'object' && !Array.isArray(attributes)) {
Object.assign(hostAttributes, attributes);
}
delete formatAttributes[formatToken];
});
return {
...run,
formats: nextFormats,
formatAttributes,
};
});
return {
runs: normalizedRuns,
hostAttributes,
};
}
/**
* Apply hoisted inline-format attributes onto one host element.
*
* @param {Element|null} hostElement Live host element.
* @param {Object|null} hostAttributes Hoisted host attributes.
* @returns {void}
*/
function applyStructuredHostLevelFormatAttributes(hostElement, hostAttributes = null) {
if (!hostElement || typeof hostElement.setAttribute !== 'function' || typeof hostElement.removeAttribute !== 'function') {
return;
}
const attributes = hostAttributes && typeof hostAttributes === 'object' ? hostAttributes : {};
['href', 'target', 'rel'].forEach(attributeName => {
const value = typeof attributes[attributeName] === 'string'
? attributes[attributeName].trim()
: '';
if (value) {
hostElement.setAttribute(attributeName, value);
return;
}
hostElement.removeAttribute(attributeName);
});
}
/**
* Build deterministic HTML from one normalized structured run sequence.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Object} editorOptions Runtime editor options.
* @param {Element|null} hostElement Live host element.
* @returns {{html: string, hostAttributes: Object}} Rendered HTML fragment.
*/
function buildStructuredHtmlFromRuns(runs, inlineCapabilities, editorOptions = {}, hostElement = null) {
const container = document.createElement('div');
const extractionOptions = editorOptions?.options && typeof editorOptions.options === 'object'
? editorOptions.options
: {};
const hoisted = hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement);
(Array.isArray(hoisted.runs) ? hoisted.runs : []).forEach(run => {
const text = String(run?.text || '');
if (!text) {
return;
}
const segments = extractionOptions.newlinesToBR === true || String(editorOptions?.enterMode || '').trim() === 'linebreak'
? text.split('\n')
: [text];
segments.forEach((segment, index) => {
if (index > 0) {
container.appendChild(document.createElement('br'));
}
if (!segment) {
return;
}
let node = document.createTextNode(segment);
(Array.isArray(run.formats) ? run.formats : []).forEach(formatToken => {
const wrapper = buildStructuredFormatWrapper(
inlineCapabilities,
formatToken,
run.formatAttributes && typeof run.formatAttributes === 'object'
? run.formatAttributes[formatToken] || null
: null
);
if (!wrapper) {
return;
}
wrapper.appendChild(node);
node = wrapper;
});
container.appendChild(node);
});
});
return {
html: container.innerHTML,
hostAttributes: hoisted.hostAttributes,
};
}
/**
* Apply structured component updates onto the active editor DOM.
*
* @param {Object} editorState Active editor state.
* @param {Array} componentUpdates Normalized component updates.
* @returns {string[]} Updated component IDs.
*/
function applyStructuredComponentUpdates(editorState, componentUpdates) {
const componentMap = getActiveEditorComponentMap(editorState);
const updatedComponentIds = [];
(Array.isArray(componentUpdates) ? componentUpdates : []).forEach(componentUpdate => {
const componentId = String(componentUpdate?.componentId || '').trim();
const component = componentMap[componentId] || null;
if (!component || !component.element) {
return;
}
if (componentUpdate.bindingSource === 'plaintext') {
component.element.textContent = (Array.isArray(componentUpdate.runs) ? componentUpdate.runs : [])
.map(run => String(run?.text || ''))
.join('');
updatedComponentIds.push(componentId);
return;
}
if (componentUpdate.bindingSource === 'html') {
const rendered = buildStructuredHtmlFromRuns(
componentUpdate.runs,
componentUpdate.inlineCapabilities || {},
componentUpdate.editorOptions || component.editorOptions || {},
component.element
);
component.element.innerHTML = rendered.html;
applyStructuredHostLevelFormatAttributes(component.element, rendered.hostAttributes);
updatedComponentIds.push(componentId);
}
});
return Array.from(new Set(updatedComponentIds));
}
/**
* Resolve the active list-editor state for one target block UUID.
*
* Structural list operations intentionally require a live open editor so the
* mutation happens inside the same DOM/save session FrontEdit already owns.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Active list editor state.
*/
function resolveActiveListEditorState(options = {}) {
const activeEditor = resolveActiveEditorState(options);
if (!activeEditor) {
return null;
}
const listTracker = SFE.ListBlockTracker || null;
if (
!listTracker ||
!activeEditor.element ||
(activeEditor.element.tagName !== 'UL' && activeEditor.element.tagName !== 'OL')
) {
return null;
}
if (!activeEditor.listTracker || activeEditor.listTracker.listElement !== activeEditor.element) {
activeEditor.listTracker = listTracker.init(
activeEditor.element,
activeEditor.blockState || {}
);
}
return activeEditor.listTracker ? activeEditor : null;
}
/**
* Refresh one active list editor after a structural DOM mutation.
*
* @param {Object} editorState Active list editor state.
* @returns {void}
*/
function syncActiveListEditorState(editorState) {
if (!editorState?.element || !editorState?.handler) {
return;
}
if (editorState.listTracker?.listElement && editorState.listTracker.listElement !== editorState.element) {
editorState.element = editorState.listTracker.listElement;
const editorHost = resolveActiveEditorHost(editorState);
if (editorHost && typeof editorHost === 'object') {
editorHost.element = editorState.listTracker.listElement;
}
}
syncActiveEditorState(editorState);
}
/**
* Apply one or more schema-declared block-attribute operations to the active editor.
*
* @param {Object} options Block-attribute operation options.
* @returns {Object|null} Result summary and current tracked attribute changes.
*/
function applyBlockAttributeOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeBlockAttributeOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
attributeChanges: bridge.clonePlainData(executionResult.attributeChanges || {}),
};
}
/**
* Apply one or more component-content replacement operations to the active editor.
*
* The shared executor owns rich-text run rendering and link normalization so
* external callers can target component surfaces without reimplementing FrontEdit's
* browser mutation semantics.
*
* @param {Object} options Component-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyTextComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeComponentOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more schema-backed media replacements to the active editor.
*
* This targets the currently active media-session host so external callers
* can replace schema media components without bypassing FrontEdit's own preview and
* resolved-media update pipeline.
*
* @param {Object} options Media-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyMediaComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeMediaOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeMediaOperations({
editorState,
editorHost,
operations,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more high-level public list operations to the currently open
* list editor.
*
* The runtime API accepts UUID-oriented public commands and lets the shared
* executor translate them into the internal primitive tracker operations.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Result summary and next list structure.
*/
function applyListOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveListEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations
: (options.operation ? [ options.operation ] : []);
const operationExecutor = SFE.SchemaOperationExecutor || null;
const listTracker = SFE.ListBlockTracker || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeListOperations !== 'function' ||
!listTracker
) {
return null;
}
const executionResult = operationExecutor.executeListOperations({
tracker: editorState.listTracker,
editorHost,
operations,
targetResolutionMode: 'api_uuid',
saveHistory: true,
afterSync: function() {
syncActiveListEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
structure: listTracker.getStructure(editorState.listTracker),
};
}
/**
* Apply one normalized structured edit payload to the active schema editor.
*
* This keeps non-list staged edits inside the same public runtime contract as
* list operations: open the editor first, then let FrontEdit own the mutation and
* history bookkeeping.
*
* @param {Object} options Structured-edit options.
* @returns {Object|null} Result summary for the applied edit.
*/
function applyStructuredEditToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const componentUpdates = Array.isArray(options.componentUpdates)
? options.componentUpdates.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const attributeOperations = Array.isArray(options.attributeOperations)
? options.attributeOperations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (!editorState || !editorHost || (!componentUpdates.length && !attributeOperations.length)) {
return null;
}
let attributeResult = null;
let componentResult = null;
if (
componentUpdates.length
&& operationExecutor
&& typeof operationExecutor.executeComponentOperations === 'function'
) {
componentResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations: componentUpdates,
saveHistory: false,
});
}
if (
attributeOperations.length &&
operationExecutor &&
typeof operationExecutor.executeBlockAttributeOperations === 'function'
) {
attributeResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations: attributeOperations,
saveHistory: false,
});
}
const didApplyAttributes = !!(
attributeResult &&
Array.isArray(attributeResult.operationsApplied) &&
attributeResult.operationsApplied.length
);
const didApplyComponents = !!(
componentResult &&
Array.isArray(componentResult.updatedComponentIds) &&
componentResult.updatedComponentIds.length
);
if (!didApplyComponents && !didApplyAttributes) {
return null;
}
syncActiveEditorState(editorState);
const historyApi = getSessionHistoryApiForHost(editorHost);
if (typeof historyApi?.saveToHistory === 'function') {
historyApi.saveToHistory();
}
if (typeof editorHost.updateToolbarState === 'function') {
editorHost.updateToolbarState();
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(componentResult?.updatedComponentIds)
? componentResult.updatedComponentIds
: [],
operationsApplied: [
...(Array.isArray(componentResult?.operationsApplied) ? componentResult.operationsApplied : []),
...(Array.isArray(attributeResult?.operationsApplied) ? attributeResult.operationsApplied : []),
],
attributeChanges: bridge.clonePlainData(editorHost.attributeChanges || {}),
};
}
/**
* Return a structural snapshot for one list block.
*
* This resolves against the live DOM so external tooling can inspect the
* current nested list tree without parsing serialized block markup itself.
*
* @param {Object} options Lookup options.
* @returns {Object|null} List structure snapshot.
*/
function getListStructure(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const listTracker = SFE.ListBlockTracker || null;
if (
!uuid ||
!(element instanceof Element) ||
!listTracker ||
(element.tagName !== 'UL' && element.tagName !== 'OL')
) {
return null;
}
const tracker = element._mwpListTracker
|| listTracker.init(element, resolveBlockState(uuid) || {});
return tracker && typeof listTracker.getStructure === 'function'
? listTracker.getStructure(tracker)
: null;
}
/**
* Apply one selected media item to the active schema-media editor session.
*
* This uses the same internal selection transition FrontEdit normally runs after
* the user picks an item from the media library or upload flow.
*
* @param {Object} options Media-selection options.
* @returns {Object|null} Stable editor snapshot after the selection is applied.
*/
function applyActiveMediaSelection(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim();
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
const editorHost = resolveActiveEditorHost(activeEditor);
const url = String(options.url || '').trim();
if (!editorHost || typeof editorHost.applyMediaSelection !== 'function' || !url) {
return null;
}
const attachmentId = Object.prototype.hasOwnProperty.call(options, 'attachmentId')
? options.attachmentId
: null;
const fromState = String(options.source || '').trim().toLowerCase() === 'library'
? 'library'
: 'input';
const didApply = editorHost.applyMediaSelection(url, attachmentId, { fromState });
return didApply === false ? null : buildEditorSnapshot(activeEditor);
}
/**
* Refresh one block through the supported server-rendered replacement path.
*
* @param {string} uuid Block UUID.
* @param {Object} [options={}] Refresh options.
* @returns {Promise} Refreshed block snapshot.
*/
async function refreshBlock(uuid, options = {}) {
const normalizedUuid = String(uuid || '').trim();
const element = getElementByUuid(normalizedUuid);
if (
!normalizedUuid ||
!(element instanceof Element) ||
!SFE.SaveHelpers ||
typeof SFE.SaveHelpers.fetchRenderedBlockHTML !== 'function' ||
!SFE.ElementUpdater ||
typeof SFE.ElementUpdater.applyNewHTML !== 'function'
) {
return null;
}
const html = await SFE.SaveHelpers.fetchRenderedBlockHTML(normalizedUuid, options || {});
if (!html) {
return null;
}
const newElement = SFE.ElementUpdater.applyNewHTML(element, normalizedUuid, html);
if (!newElement) {
return null;
}
if (typeof SFE.ElementUpdater.rebindElement === 'function') {
SFE.ElementUpdater.rebindElement(newElement);
}
const block = buildBlockSnapshot(normalizedUuid);
if (block) {
bridge.emitEvent('block:refreshed', {
source: String(options.source || 'sfe').trim() || 'sfe',
block,
});
}
return block;
}
/**
* Return one public dirty-block snapshot.
*
* @param {Object} entry Dirty entry from the batch manager.
* @returns {Object|null} Dirty block snapshot.
*/
function buildDirtyBlockSnapshot(entry) {
if (!entry || typeof entry !== 'object') {
return null;
}
return {
uuid: String(entry.element_uuid || '').trim(),
handlerId: String(entry.handler_id || '').trim(),
blockName: String(entry.blockName || '').trim(),
beforeRaw: String(entry.before || '').trim(),
afterRaw: String(entry.after || '').trim(),
};
}
/**
* Reset dirty batch state for one or more target UUIDs.
*
* @param {string[]} uuids Target UUIDs.
* @returns {boolean} Whether any batch state was reset.
*/
function resetDirtyBlocks(uuids) {
const batchManager = SFE.BatchEditManager || null;
const normalizedUuids = Array.isArray(uuids)
? uuids.map(uuid => String(uuid || '').trim()).filter(Boolean)
: [];
if (!normalizedUuids.length || !batchManager) {
return false;
}
if (typeof batchManager.resetDirtyBlocks === 'function') {
return !!batchManager.resetDirtyBlocks(normalizedUuids);
}
let changed = false;
normalizedUuids.forEach(uuid => {
if (batchManager.dirtyBlocks instanceof Map && batchManager.dirtyBlocks.has(uuid)) {
batchManager.dirtyBlocks.delete(uuid);
changed = true;
}
if (
batchManager.currentBlockStates instanceof Map &&
batchManager.baseBlockStates instanceof Map &&
batchManager.baseBlockStates.has(uuid)
) {
batchManager.currentBlockStates.set(
uuid,
bridge.clonePlainData(batchManager.baseBlockStates.get(uuid))
);
changed = true;
}
});
return changed;
}
/**
* Return the stable PublicApi discovery snapshot.
*
* @returns {Object} API metadata.
*/
function getApiInfo() {
return {
apiVersion: 1,
namespace: 'window.MWP.SFE.PublicApi',
features: {
editorControl: true,
runtimeInspection: true,
editableBlockDiscovery: true,
editingRuntimeResolution: true,
textComponentOperations: true,
mediaComponentOperations: true,
mediaInspection: true,
mediaSessionControl: true,
explicitStaging: true,
events: true,
blockRefresh: true,
},
};
}
PublicApi._buildEditorSnapshot = buildEditorSnapshot;
PublicApi.getApiInfo = getApiInfo;
PublicApi.isEditorOpen = function isEditorOpen() {
return !!getContext().activeEditor;
};
PublicApi.getActiveEditor = function getActiveEditor() {
return buildEditorSnapshot(getContext().activeEditor || null);
};
PublicApi.applyActiveMediaSelection = function applyActiveMediaSelectionPublic(options = {}) {
return applyActiveMediaSelection(options);
};
PublicApi.getPageContext = function getPageContext() {
const context = getContext();
const managerData = getManagerData();
return {
postId: Number(managerData.postId || 0) || 0,
permissions: bridge.clonePlainData(managerData.permissions || {}),
hasDraftPreview: !!(
document.body.classList.contains('mwp-sfe-active-preview') ||
context.activeMode === 'draft'
),
isEditorOpen: !!context.activeEditor,
activeMode: String(context.activeMode || '').trim(),
};
};
PublicApi.getRestContext = function getRestContext() {
const managerData = getManagerData();
return {
baseUrl: String(managerData.restBase || '').trim(),
namespaceUrl: String(managerData.restUrl || '').trim(),
nonce: String(managerData.nonce || '').trim(),
};
};
PublicApi.setRestNonce = function setRestNonce(nonce) {
const normalizedNonce = normalizeRestNonce(nonce);
if (!normalizedNonce) {
return PublicApi.getRestContext();
}
const managerData = getManagerData();
managerData.nonce = normalizedNonce;
SFE.ManagerData = managerData;
return PublicApi.getRestContext();
};
PublicApi.getElementByUuid = getElementByUuid;
PublicApi.getUuidForElement = getUuidForElement;
PublicApi.getBlockSnapshot = function getBlockSnapshot(uuid) {
return buildBlockSnapshot(uuid);
};
PublicApi.getEditableBlocks = getEditableBlocks;
PublicApi.resolveRuntime = function resolveRuntime(options = {}) {
return buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.resolveEditingRuntime = function resolveEditingRuntime(options = {}) {
return buildResolvedEditingRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.getEditableComponents = function getEditableComponents(options = {}) {
const runtime = buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
return runtime ? runtime.components : [];
};
PublicApi.getListStructure = getListStructure;
PublicApi.getDefaultComponent = function getDefaultComponent(options = {}) {
const components = PublicApi.getEditableComponents(options);
return components.find(component => component.default) || components[0] || null;
};
PublicApi.getMediaDescriptor = function getMediaDescriptor(options = {}) {
return resolveMediaDescriptor(options);
};
PublicApi.getMediaContext = function getMediaContext(options = {}) {
const descriptor = resolveMediaDescriptor(options);
const mediaHelper = SFE.MediaHelper || null;
if (!descriptor || !mediaHelper || typeof mediaHelper.getMediaType !== 'function') {
return null;
}
const mediaType = String(mediaHelper.getMediaType(descriptor) || '').trim();
if (!mediaType) {
return null;
}
return {
supported: true,
componentId: String(descriptor.componentId || '').trim(),
mediaType,
accept: typeof mediaHelper.getAcceptTypes === 'function'
? String(mediaHelper.getAcceptTypes(descriptor) || '*/*').trim() || '*/*'
: '*/*',
label: mediaType === 'audio' ? 'audio block' : (mediaType === 'video' ? 'video block' : (mediaType === 'file' ? 'file block' : 'media block')),
descriptor,
};
};
PublicApi.isMediaEditable = function isMediaEditable(options = {}) {
return !!PublicApi.getMediaContext(options);
};
PublicApi.openEditor = openEditor;
PublicApi.closeEditor = closeEditor;
PublicApi.applyTextComponentOperations = applyTextComponentOperationsToActiveEditor;
PublicApi.applyMediaComponentOperations = applyMediaComponentOperationsToActiveEditor;
PublicApi.applyBlockAttributeOperations = applyBlockAttributeOperationsToActiveEditor;
PublicApi.applyListOperations = applyListOperationsToActiveEditor;
PublicApi.applyStructuredEdit = applyStructuredEditToActiveEditor;
PublicApi.stageBlockState = function stageBlockState(stage) {
const uuid = String(stage && stage.uuid ? stage.uuid : '').trim();
if (!uuid || !stage || typeof stage !== 'object' || !stage.blockState || typeof stage.blockState !== 'object') {
return;
}
bridge.stagedBlockStates.set(uuid, {
handlerId: String(stage.handlerId || '').trim(),
source: String(stage.source || 'external').trim() || 'external',
blockState: bridge.clonePlainData(stage.blockState),
});
bridge.emitEvent('block:staged', {
source: String(stage.source || 'external').trim() || 'external',
uuid,
handlerId: String(stage.handlerId || '').trim(),
});
};
PublicApi.clearStagedBlockState = function clearStagedBlockState(uuid, source = 'external') {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid) {
return;
}
bridge.stagedBlockStates.delete(normalizedUuid);
bridge.emitEvent('block:stageCleared', {
source: String(source || 'external').trim() || 'external',
uuid: normalizedUuid,
});
};
PublicApi.refreshBlock = refreshBlock;
PublicApi.getDirtyBlocks = function getDirtyBlocks() {
const batchManager = SFE.BatchEditManager || null;
if (!batchManager || !(batchManager.dirtyBlocks instanceof Map)) {
return [];
}
return Array.from(batchManager.dirtyBlocks.values())
.map(buildDirtyBlockSnapshot)
.filter(entry => entry && entry.uuid);
};
PublicApi.hasDirtyBlocks = function hasDirtyBlocks() {
return PublicApi.getDirtyBlocks().length > 0;
};
PublicApi.isBatchSessionActive = function isBatchSessionActive() {
const batchManager = SFE.BatchEditManager || null;
return !!(
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive()
);
};
PublicApi.resetDirtyBlocks = function resetDirtyBlocksPublic(uuids) {
return resetDirtyBlocks(uuids);
};
SFE.PublicApi = PublicApi;
})();
/**
* Stable frontend runtime PublicApi implementation.
*
* Exposes: SFE.PublicApi
* {
* getApiInfo, on, off, isEditorOpen, getActiveEditor,
* applyActiveMediaSelection, getPageContext, getRestContext, setRestNonce,
* getElementByUuid, getUuidForElement, getBlockSnapshot, getEditableBlocks,
* resolveRuntime,
* resolveEditingRuntime, getEditableComponents, getListStructure,
* getDefaultComponent, getMediaDescriptor, getMediaContext,
* isMediaEditable, openEditor, closeEditor, applyTextComponentOperations,
* applyMediaComponentOperations,
* applyBlockAttributeOperations,
* applyListOperations, applyStructuredEdit, stageBlockState,
* clearStagedBlockState, refreshBlock, getDirtyBlocks, hasDirtyBlocks,
* isBatchSessionActive, resetDirtyBlocks
* }
*
* Keeps mutable runtime internals private while exposing the documented browser
* integration surface for external consumers such as ABE.
*/
(function() {
'use strict';
window.MWP = window.MWP || {};
window.MWP.SFE = window.MWP.SFE || {};
const SFE = window.MWP.SFE;
SFE.ManagerData = SFE.ManagerData || {};
const PublicApi = SFE.PublicApi || {};
const bridge = SFE.PublicApiBridge || null;
if (!bridge) {
return;
}
/**
* Resolve the shared runtime context object.
*
* @returns {Object} Shared FrontEdit context.
*/
function getContext() {
return SFE.Context || {};
}
/**
* Resolve the localized bootstrap payload.
*
* @returns {Object} Localized manager data.
*/
function getManagerData() {
return SFE.ManagerData || {};
}
/**
* Normalize one candidate REST nonce.
*
* @param {*} nonce Candidate nonce value.
* @returns {string} Trimmed nonce or an empty string.
*/
function normalizeRestNonce(nonce) {
return String(nonce || '').trim();
}
/**
* Return the live block element for one UUID.
*
* @param {string} uuid Block UUID.
* @returns {Element|null} Matching element.
*/
function getElementByUuid(uuid) {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || typeof document.querySelector !== 'function') {
return null;
}
try {
return document.querySelector(`[data-mwp-sfe-uuid="${CSS.escape(normalizedUuid)}"]`);
} catch (error) {
return document.querySelector(`[data-mwp-sfe-uuid="${normalizedUuid.replace(/"/g, '\\"')}"]`);
}
}
/**
* Resolve one UUID from a supplied element or nested child.
*
* @param {Element|null} element Candidate DOM node.
* @returns {string} Block UUID or an empty string.
*/
function getUuidForElement(element) {
if (!(element instanceof Element)) {
return '';
}
const candidate = element.closest('[data-mwp-sfe-uuid]');
return candidate instanceof Element
? String(candidate.getAttribute('data-mwp-sfe-uuid') || '').trim()
: '';
}
/**
* Resolve one uuid-map entry from the shared context.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} UUID map entry.
*/
function getUuidEntry(uuid) {
const context = getContext();
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || !context.uuidMap || !context.uuidMap[normalizedUuid]) {
return null;
}
return context.uuidMap[normalizedUuid];
}
/**
* Resolve one edit-capable handler for the supplied target.
*
* @param {Object} options Resolution options.
* @returns {Object|null} Edit handler when supported.
*/
function resolveEditHandler(options = {}) {
const element = options.element instanceof Element ? options.element : null;
const preferredHandlerId = String(options.handlerId || '').trim();
const handlers = Array.isArray(element?._mwpSfeHandlers)
? element._mwpSfeHandlers
: [];
if (preferredHandlerId) {
const exact = handlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
));
if (exact) {
return exact;
}
}
const fromElement = handlers.find(handler => handler && handler.capability === 'edit') || null;
if (fromElement) {
return fromElement;
}
const uuidEntry = getUuidEntry(options.uuid);
const managerData = getManagerData();
const registeredHandlers = Array.isArray(managerData.handlers) ? managerData.handlers : [];
const handlerIds = Array.isArray(uuidEntry?.handlers) ? uuidEntry.handlers : [];
if (preferredHandlerId) {
return registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
)) || null;
}
for (let index = 0; index < handlerIds.length; index++) {
const handlerId = String(handlerIds[index] || '').trim();
const match = registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === handlerId
));
if (match) {
return match;
}
}
return null;
}
/**
* Resolve the current block-state payload used for schema hydration.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} Block-state payload when available.
*/
function resolveBlockState(uuid) {
const batchManager = SFE.BatchEditManager || null;
if (
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive() &&
typeof batchManager.getBlockStateForUuid === 'function'
) {
return batchManager.getBlockStateForUuid(uuid);
}
return null;
}
/**
* Resolve the schema runtime bundle for one target block.
*
* @param {Object} options Runtime resolution options.
* @returns {Object|null} Schema runtime bundle.
*/
function resolveRuntimeBundle(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const schemaRuntime = SFE.SchemaRuntime || null;
if (!uuid || !(element instanceof Element) || !handler || !schemaRuntime || typeof schemaRuntime.resolveForEditing !== 'function') {
return null;
}
try {
const blockState = options.blockState && typeof options.blockState === 'object'
? options.blockState
: resolveBlockState(uuid);
const attributeChanges = options.attributeChanges && typeof options.attributeChanges === 'object'
? options.attributeChanges
: undefined;
const resolved = schemaRuntime.resolveForEditing(element, handler, {
blockState,
attributeChanges,
});
if (!resolved || !resolved.runtimeHandler || !resolved.runtime) {
return null;
}
return {
uuid,
element,
handler: resolved.runtimeHandler,
runtime: resolved.runtime,
schema: resolved.schema || null,
};
} catch (error) {
console.warn('FrontEdit: PublicApi resolveRuntime failed', error);
return null;
}
}
/**
* Build one detailed editable-component snapshot from a schema runtime entry.
*
* @param {Object|null} editableComponent Runtime editable component.
* @param {Object|null} componentMeta Additional component metadata.
* @returns {Object|null} Detailed component snapshot.
*/
function buildEditingRuntimeComponentDetail(editableComponent, componentMeta = null) {
const snapshot = buildEditableComponentSnapshot(editableComponent);
if (!snapshot) {
return null;
}
const meta = componentMeta && typeof componentMeta === 'object' ? componentMeta : {};
snapshot.element = editableComponent?.element instanceof Element
? editableComponent.element
: (meta.element instanceof Element ? meta.element : null);
const bindings = Array.isArray(meta.bindings)
? bridge.clonePlainData(meta.bindings)
: [];
if (bindings.length) {
snapshot.bindings = bindings;
}
const target = meta.target && typeof meta.target === 'object'
? bridge.clonePlainData(meta.target)
: (snapshot.target || null);
if (target) {
snapshot.target = target;
}
const editorOptions = editableComponent?.editorOptions && typeof editableComponent.editorOptions === 'object'
? bridge.clonePlainData(editableComponent.editorOptions)
: (meta.editorOptions && typeof meta.editorOptions === 'object'
? bridge.clonePlainData(meta.editorOptions)
: null);
if (editorOptions) {
snapshot.editorOptions = editorOptions;
snapshot.editor = bridge.clonePlainData(editorOptions);
}
return snapshot;
}
/**
* Build one detailed schema-resolved editing runtime snapshot.
*
* This exposes the same resolved component metadata FrontEdit uses for editing
* while keeping handler resolution and schema runtime execution owned by FrontEdit.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Detailed editing runtime snapshot.
*/
function buildResolvedEditingRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const runtimeComponentsById = bundle.runtime.componentsById && typeof bundle.runtime.componentsById === 'object'
? bundle.runtime.componentsById
: {};
const componentDetails = [];
const componentsById = {};
(Array.isArray(bundle.runtime.editableComponents) ? bundle.runtime.editableComponents : []).forEach(component => {
const componentId = String(component?.id || '').trim();
const detail = buildEditingRuntimeComponentDetail(component, componentId ? runtimeComponentsById[componentId] : null);
if (!detail || !componentId) {
return;
}
componentDetails.push(detail);
componentsById[componentId] = detail;
});
Object.keys(runtimeComponentsById).forEach(componentId => {
if (componentsById[componentId]) {
return;
}
const detail = buildEditingRuntimeComponentDetail(runtimeComponentsById[componentId], runtimeComponentsById[componentId]);
if (!detail) {
return;
}
detail.id = componentId;
componentDetails.push(detail);
componentsById[componentId] = detail;
});
const mediaComponentId = String(bundle.runtime?.mediaComponent?.id || '').trim();
const mediaComponent = mediaComponentId && componentsById[mediaComponentId]
? componentsById[mediaComponentId]
: null;
return {
uuid: bundle.uuid,
element: bundle.element instanceof Element ? bundle.element : null,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
runtimeHandler: {
id: String(bundle.handler.id || '').trim(),
},
runtime: {
blockName: String(bundle.runtime.blockName || '').trim(),
editableComponents: componentDetails,
componentsById,
mediaComponent,
},
schema: {
handlerId: String(bundle.schema?.handlerId || bundle.handler.id || '').trim(),
},
};
}
/**
* Return a plain snapshot of one editable component.
*
* @param {Object|null} component Runtime component.
* @returns {Object|null} Public component snapshot.
*/
function buildEditableComponentSnapshot(component) {
if (!component || typeof component !== 'object') {
return null;
}
const snapshot = {
id: String(component.id || '').trim(),
label: String(component.label || component.id || '').trim(),
type: String(component.type || '').trim().toLowerCase(),
selector: String(component.selector || '').trim(),
default: !!component.default,
};
if (!snapshot.id || !snapshot.type) {
return null;
}
if (component.required === true) {
snapshot.required = true;
}
if (typeof component.placeholder === 'string' && component.placeholder.trim()) {
snapshot.placeholder = component.placeholder;
}
if (component.target && typeof component.target === 'object') {
snapshot.target = bridge.clonePlainData(component.target);
}
if (component.mediaDescriptor && typeof component.mediaDescriptor === 'object') {
snapshot.mediaDescriptor = bridge.clonePlainData(component.mediaDescriptor);
}
if (component.editorOptions && typeof component.editorOptions === 'object') {
snapshot.editor = bridge.clonePlainData(component.editorOptions);
}
return snapshot;
}
/**
* Resolve the public runtime mode label.
*
* @param {Object|null} runtime Schema runtime.
* @returns {string} Runtime mode label.
*/
function resolvePublicRuntimeMode(runtime) {
const components = Array.isArray(runtime?.editableComponents) ? runtime.editableComponents : [];
const hasText = components.some(component => String(component?.type || '').trim().toLowerCase() !== 'file');
const hasFile = components.some(component => String(component?.type || '').trim().toLowerCase() === 'file');
if (hasText && hasFile) {
return 'mixed';
}
if (hasFile) {
return 'file';
}
return 'text';
}
/**
* Build one public runtime snapshot from a schema bundle.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Public runtime snapshot.
*/
function buildResolvedRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const components = Array.isArray(bundle.runtime.editableComponents)
? bundle.runtime.editableComponents.map(buildEditableComponentSnapshot).filter(Boolean)
: [];
const defaultComponent = components.find(component => component.default) || components[0] || null;
return {
uuid: bundle.uuid,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
mode: resolvePublicRuntimeMode(bundle.runtime),
defaultComponentId: defaultComponent ? defaultComponent.id : '',
components,
};
}
/**
* Resolve a public media descriptor for one target block.
*
* @param {Object} options Media resolution options.
* @returns {Object|null} Media descriptor snapshot.
*/
function resolveMediaDescriptor(options = {}) {
const runtime = resolveRuntimeBundle(options);
if (!runtime) {
return null;
}
const componentId = String(options.componentId || '').trim();
const components = Array.isArray(runtime.runtime.editableComponents) ? runtime.runtime.editableComponents : [];
const selected = componentId
? components.find(component => component && component.id === componentId)
: (
(runtime.runtime.mediaComponent && typeof runtime.runtime.mediaComponent === 'object'
? runtime.runtime.mediaComponent
: components.find(component => String(component?.type || '').trim().toLowerCase() === 'file')
) || null
);
if (!selected || !selected.mediaDescriptor || typeof selected.mediaDescriptor !== 'object') {
return null;
}
return bridge.clonePlainData(selected.mediaDescriptor);
}
/**
* Build one stable block snapshot.
*
* @param {string} uuid Target UUID.
* @returns {Object|null} Block snapshot.
*/
function buildBlockSnapshot(uuid) {
const normalizedUuid = String(uuid || '').trim();
const entry = getUuidEntry(normalizedUuid);
if (!normalizedUuid || !entry) {
return null;
}
return {
uuid: normalizedUuid,
blockName: String(entry.blockName || '').trim(),
handlerIds: Array.isArray(entry.handlers) ? entry.handlers.slice() : [],
isPending: !!entry.is_pending,
pendingInfo: entry.pending_info ? bridge.clonePlainData(entry.pending_info) : null,
elementPresent: !!getElementByUuid(normalizedUuid),
};
}
/**
* Return stable discovery snapshots for every editable block on this page.
*
* @returns {Array} Editable block snapshots in FrontEdit UUID-map order.
*/
function getEditableBlocks() {
const context = getContext();
const uuidMap = context.uuidMap && typeof context.uuidMap === 'object'
? context.uuidMap
: {};
return Object.keys(uuidMap)
.map(uuid => {
const snapshot = buildBlockSnapshot(uuid);
if (!snapshot) {
return null;
}
const element = getElementByUuid(uuid);
return {
...snapshot,
contentText: element instanceof Element
? String(element.textContent || '').replace(/\s+/g, ' ').trim()
: '',
};
})
.filter(Boolean);
}
/**
* Determine whether a block currently has tracked unsaved changes.
*
* @param {string} uuid Block UUID.
* @returns {boolean} Whether the block is dirty.
*/
function isDirtyUuid(uuid) {
const batchManager = SFE.BatchEditManager || null;
return !!(
uuid &&
batchManager &&
batchManager.dirtyBlocks instanceof Map &&
batchManager.dirtyBlocks.has(uuid)
);
}
/**
* Build one public editor snapshot from a live editor state object.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object|null} Stable editor snapshot.
*/
function buildEditorSnapshot(editorState) {
if (!editorState || !editorState.uuid) {
return null;
}
const draftEditState = getContext().draftEditState;
const isDraftSession = !!(
draftEditState &&
draftEditState.draftElement &&
draftEditState.draftElement === editorState.element
);
const activeComponentId = String(
editorState.activeComponentId
|| editorState.activeEditableComponent?.id
|| ''
).trim();
const activeComponentType = String(
editorState._mwpActiveComponentType
|| editorState.activeEditableComponent?.type
|| (editorState.isMediaEditor ? 'file' : 'text')
).trim().toLowerCase();
const activeEditorHost = resolveActiveEditorHost(editorState);
return {
uuid: String(editorState.uuid || '').trim(),
handlerId: String(editorState._mwpSchemaHandlerId || editorState.handler?.id || '').trim(),
mode: String(editorState.requestedMode || (isDraftSession ? 'draft' : 'edit')).trim() || 'edit',
blockName: String(editorState.blockName || editorState.blockState?.blockName || '').trim(),
isOpen: true,
componentType: activeComponentType || 'text',
componentId: activeComponentId,
saveStrategy: String(editorState.saveStrategy || 'single').trim() || 'single',
hasMediaSession: typeof activeEditorHost?.applyMediaSelection === 'function',
isDirty: isDirtyUuid(editorState.uuid),
isDraftSession,
isBatchSession: !!(
editorState.saveStrategy === 'batch' &&
SFE.BatchEditManager &&
typeof SFE.BatchEditManager.isSessionActive === 'function' &&
SFE.BatchEditManager.isSessionActive()
),
};
}
/**
* Switch the active editable component inside one open editor session.
*
* @param {Object} editorState Active editor state.
* @param {string} componentId Target component identifier.
* @returns {boolean} Whether the switch succeeded.
*/
function activateEditorComponent(editorState, componentId) {
if (!editorState || !componentId) {
return false;
}
if (SFE.TextEditor && typeof SFE.TextEditor.activateEditableComponentById === 'function') {
return !!SFE.TextEditor.activateEditableComponentById(editorState, componentId);
}
return false;
}
/**
* Open one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Open-editor options.
* @returns {Promise} Editor snapshot after opening.
*/
async function openEditor(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const componentId = String(options.componentId || '').trim();
if (!uuid || !(element instanceof Element) || !handler || typeof SFE.startEditing !== 'function') {
return null;
}
const activeEditor = getContext().activeEditor || null;
if (activeEditor && String(activeEditor.uuid || '').trim() === uuid) {
if (componentId) {
activateEditorComponent(activeEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || activeEditor);
}
if (activeEditor && typeof SFE.closeInPlaceEditor === 'function') {
SFE.closeInPlaceEditor(activeEditor, true, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
});
}
await Promise.resolve(
SFE.startEditing(
element,
handler,
uuid,
null,
false,
String(options.mode || 'edit').trim() || 'edit',
{
initialComponentId: componentId,
source: String(options.source || 'external').trim() || 'external',
originalSnapshots: options.originalSnapshots && typeof options.originalSnapshots === 'object'
? {
restoreOuterHTML: String(options.originalSnapshots.restoreOuterHTML || '').trim(),
cleanOuterHTML: String(options.originalSnapshots.cleanOuterHTML || '').trim(),
}
: null,
}
)
);
const openedEditor = getContext().activeEditor || null;
if (openedEditor && componentId) {
activateEditorComponent(openedEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || openedEditor);
}
/**
* Close one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Close-editor options.
* @returns {boolean} Whether a close was attempted.
*/
function closeEditor(options = {}) {
const activeEditor = getContext().activeEditor || null;
if (!activeEditor || typeof SFE.closeInPlaceEditor !== 'function') {
return false;
}
const targetUuid = String(options.uuid || '').trim();
if (targetUuid && String(activeEditor.uuid || '').trim() !== targetUuid) {
return false;
}
return SFE.closeInPlaceEditor(activeEditor, options.restoreOriginal !== false, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
}) !== false;
}
/**
* Resolve the active editor state for one target block UUID.
*
* Schema-backed editor operations intentionally require a live open editor so
* the DOM mutation stays inside the same save/history session FrontEdit owns.
*
* @param {Object} options Editor-operation options.
* @returns {Object|null} Active editor state.
*/
function resolveActiveEditorState(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
return resolveActiveEditorHost(activeEditor) ? activeEditor : null;
}
function resolveActiveEditorHost(editorState) {
return SFE.SchemaEditorHost?.resolveActiveEditorHost?.(editorState) || null;
}
/**
* Resolve the session-owned history API for one active editor host.
*
* External runtime mutations should commit through the same shared block
* session contract used internally instead of reaching into ad hoc
* editor-state history fields.
*
* @param {Object|null} editorHost Active schema editor host.
* @returns {Object|null} Session history API, or null when unavailable.
*/
function getSessionHistoryApiForHost(editorHost) {
if (editorHost?.historyApi && typeof editorHost.historyApi === 'object') {
return editorHost.historyApi;
}
if (typeof editorHost?.getSessionHistoryApi === 'function') {
return editorHost.getSessionHistoryApi();
}
const blockEditSession = editorHost?.blockEditSession || null;
if (!blockEditSession || typeof blockEditSession.getHistoryApi !== 'function') {
return null;
}
return blockEditSession.getHistoryApi(
String(editorHost?.blockEditSessionScopeId || '').trim() || 'text'
);
}
/**
* Refresh one active editor state after a schema-driven DOM mutation.
*
* @param {Object} editorState Active editor state.
* @returns {void}
*/
function syncActiveEditorState(editorState) {
if (!editorState?.handler) {
return;
}
const editorHost = resolveActiveEditorHost(editorState);
const blockRootElement = (
editorHost &&
typeof editorHost.getBlockRootElement === 'function'
)
? editorHost.getBlockRootElement()
: null;
if (blockRootElement && blockRootElement !== editorState.element) {
// The active schema host element can be one editable component (for
// example, one table cell), while block-session history and restore must
// keep targeting the outer block root. Rebasing `editorState.element` to
// the component host corrupts undo/redo by replaying full block markup
// into that component instead of the block wrapper.
editorState.element = blockRootElement;
}
if (!editorState.element) {
return;
}
const schemaRuntime = SFE.SchemaRuntime || null;
if (
schemaRuntime &&
typeof schemaRuntime.syncPlaceholders === 'function'
) {
schemaRuntime.syncPlaceholders(editorState.element, editorState.handler, {
blockAttributes: editorState.blockState?.attrs || null,
attributeChanges: editorState.attributeChanges || null,
});
}
if (
SFE.TextEditor &&
typeof SFE.TextEditor.refreshEditableComponents === 'function'
) {
SFE.TextEditor.refreshEditableComponents(editorState);
}
}
/**
* Build one component map for the active schema editor state.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object} Editable components keyed by ID.
*/
function getActiveEditorComponentMap(editorState) {
if (!editorState || !Array.isArray(editorState.editableComponents)) {
return {};
}
return editorState.editableComponents.reduce((map, component) => {
const componentId = String(component?.id || '').trim();
if (!componentId || !component?.element) {
return map;
}
map[componentId] = component;
return map;
}, {});
}
/**
* Return the lowercase host tag name for one candidate component element.
*
* @param {Element|null} hostElement Candidate host element.
* @returns {string} Lowercase host tag name.
*/
function getHostElementTagName(hostElement) {
return hostElement && hostElement.tagName
? String(hostElement.tagName || '').trim().toLowerCase()
: '';
}
/**
* Build one inline format wrapper for a structured run token.
*
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {string} formatToken Format token.
* @param {Object|null} formatAttributes Optional format attributes.
* @returns {HTMLElement|null} Wrapper element.
*/
function buildStructuredFormatWrapper(inlineCapabilities, formatToken, formatAttributes = null) {
const tagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!tagName) {
return null;
}
const element = document.createElement(tagName);
if (tagName === 'a' && formatAttributes && typeof formatAttributes === 'object') {
const href = String(formatAttributes.href || '').trim();
if (href) {
element.setAttribute('href', href);
}
const target = String(formatAttributes.target || '').trim();
if (target) {
element.setAttribute('target', target);
}
const rel = String(formatAttributes.rel || '').trim();
if (rel) {
element.setAttribute('rel', rel);
}
}
return element;
}
/**
* Hoist same-tag inline format attributes onto the host component element.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Element|null} hostElement Live host element.
* @returns {{runs: Array, hostAttributes: Object}} Hoisted run data.
*/
function hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement = null) {
const hostTagName = getHostElementTagName(hostElement);
if (!hostTagName) {
return {
runs: Array.isArray(runs) ? runs : [],
hostAttributes: {},
};
}
const hostAttributes = {};
const normalizedRuns = (Array.isArray(runs) ? runs : []).map(run => {
const formats = Array.isArray(run?.formats) ? run.formats : [];
const formatAttributes = run?.formatAttributes && typeof run.formatAttributes === 'object'
? { ...run.formatAttributes }
: {};
const nextFormats = [];
formats.forEach(formatToken => {
const formatTagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!formatTagName || formatTagName !== hostTagName) {
nextFormats.push(formatToken);
return;
}
const attributes = formatAttributes?.[formatToken];
if (attributes && typeof attributes === 'object' && !Array.isArray(attributes)) {
Object.assign(hostAttributes, attributes);
}
delete formatAttributes[formatToken];
});
return {
...run,
formats: nextFormats,
formatAttributes,
};
});
return {
runs: normalizedRuns,
hostAttributes,
};
}
/**
* Apply hoisted inline-format attributes onto one host element.
*
* @param {Element|null} hostElement Live host element.
* @param {Object|null} hostAttributes Hoisted host attributes.
* @returns {void}
*/
function applyStructuredHostLevelFormatAttributes(hostElement, hostAttributes = null) {
if (!hostElement || typeof hostElement.setAttribute !== 'function' || typeof hostElement.removeAttribute !== 'function') {
return;
}
const attributes = hostAttributes && typeof hostAttributes === 'object' ? hostAttributes : {};
['href', 'target', 'rel'].forEach(attributeName => {
const value = typeof attributes[attributeName] === 'string'
? attributes[attributeName].trim()
: '';
if (value) {
hostElement.setAttribute(attributeName, value);
return;
}
hostElement.removeAttribute(attributeName);
});
}
/**
* Build deterministic HTML from one normalized structured run sequence.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Object} editorOptions Runtime editor options.
* @param {Element|null} hostElement Live host element.
* @returns {{html: string, hostAttributes: Object}} Rendered HTML fragment.
*/
function buildStructuredHtmlFromRuns(runs, inlineCapabilities, editorOptions = {}, hostElement = null) {
const container = document.createElement('div');
const extractionOptions = editorOptions?.options && typeof editorOptions.options === 'object'
? editorOptions.options
: {};
const hoisted = hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement);
(Array.isArray(hoisted.runs) ? hoisted.runs : []).forEach(run => {
const text = String(run?.text || '');
if (!text) {
return;
}
const segments = extractionOptions.newlinesToBR === true || String(editorOptions?.enterMode || '').trim() === 'linebreak'
? text.split('\n')
: [text];
segments.forEach((segment, index) => {
if (index > 0) {
container.appendChild(document.createElement('br'));
}
if (!segment) {
return;
}
let node = document.createTextNode(segment);
(Array.isArray(run.formats) ? run.formats : []).forEach(formatToken => {
const wrapper = buildStructuredFormatWrapper(
inlineCapabilities,
formatToken,
run.formatAttributes && typeof run.formatAttributes === 'object'
? run.formatAttributes[formatToken] || null
: null
);
if (!wrapper) {
return;
}
wrapper.appendChild(node);
node = wrapper;
});
container.appendChild(node);
});
});
return {
html: container.innerHTML,
hostAttributes: hoisted.hostAttributes,
};
}
/**
* Apply structured component updates onto the active editor DOM.
*
* @param {Object} editorState Active editor state.
* @param {Array} componentUpdates Normalized component updates.
* @returns {string[]} Updated component IDs.
*/
function applyStructuredComponentUpdates(editorState, componentUpdates) {
const componentMap = getActiveEditorComponentMap(editorState);
const updatedComponentIds = [];
(Array.isArray(componentUpdates) ? componentUpdates : []).forEach(componentUpdate => {
const componentId = String(componentUpdate?.componentId || '').trim();
const component = componentMap[componentId] || null;
if (!component || !component.element) {
return;
}
if (componentUpdate.bindingSource === 'plaintext') {
component.element.textContent = (Array.isArray(componentUpdate.runs) ? componentUpdate.runs : [])
.map(run => String(run?.text || ''))
.join('');
updatedComponentIds.push(componentId);
return;
}
if (componentUpdate.bindingSource === 'html') {
const rendered = buildStructuredHtmlFromRuns(
componentUpdate.runs,
componentUpdate.inlineCapabilities || {},
componentUpdate.editorOptions || component.editorOptions || {},
component.element
);
component.element.innerHTML = rendered.html;
applyStructuredHostLevelFormatAttributes(component.element, rendered.hostAttributes);
updatedComponentIds.push(componentId);
}
});
return Array.from(new Set(updatedComponentIds));
}
/**
* Resolve the active list-editor state for one target block UUID.
*
* Structural list operations intentionally require a live open editor so the
* mutation happens inside the same DOM/save session FrontEdit already owns.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Active list editor state.
*/
function resolveActiveListEditorState(options = {}) {
const activeEditor = resolveActiveEditorState(options);
if (!activeEditor) {
return null;
}
const listTracker = SFE.ListBlockTracker || null;
if (
!listTracker ||
!activeEditor.element ||
(activeEditor.element.tagName !== 'UL' && activeEditor.element.tagName !== 'OL')
) {
return null;
}
if (!activeEditor.listTracker || activeEditor.listTracker.listElement !== activeEditor.element) {
activeEditor.listTracker = listTracker.init(
activeEditor.element,
activeEditor.blockState || {}
);
}
return activeEditor.listTracker ? activeEditor : null;
}
/**
* Refresh one active list editor after a structural DOM mutation.
*
* @param {Object} editorState Active list editor state.
* @returns {void}
*/
function syncActiveListEditorState(editorState) {
if (!editorState?.element || !editorState?.handler) {
return;
}
if (editorState.listTracker?.listElement && editorState.listTracker.listElement !== editorState.element) {
editorState.element = editorState.listTracker.listElement;
const editorHost = resolveActiveEditorHost(editorState);
if (editorHost && typeof editorHost === 'object') {
editorHost.element = editorState.listTracker.listElement;
}
}
syncActiveEditorState(editorState);
}
/**
* Apply one or more schema-declared block-attribute operations to the active editor.
*
* @param {Object} options Block-attribute operation options.
* @returns {Object|null} Result summary and current tracked attribute changes.
*/
function applyBlockAttributeOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeBlockAttributeOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
attributeChanges: bridge.clonePlainData(executionResult.attributeChanges || {}),
};
}
/**
* Apply one or more component-content replacement operations to the active editor.
*
* The shared executor owns rich-text run rendering and link normalization so
* external callers can target component surfaces without reimplementing FrontEdit's
* browser mutation semantics.
*
* @param {Object} options Component-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyTextComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeComponentOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more schema-backed media replacements to the active editor.
*
* This targets the currently active media-session host so external callers
* can replace schema media components without bypassing FrontEdit's own preview and
* resolved-media update pipeline.
*
* @param {Object} options Media-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyMediaComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeMediaOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeMediaOperations({
editorState,
editorHost,
operations,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more high-level public list operations to the currently open
* list editor.
*
* The runtime API accepts UUID-oriented public commands and lets the shared
* executor translate them into the internal primitive tracker operations.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Result summary and next list structure.
*/
function applyListOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveListEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations
: (options.operation ? [ options.operation ] : []);
const operationExecutor = SFE.SchemaOperationExecutor || null;
const listTracker = SFE.ListBlockTracker || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeListOperations !== 'function' ||
!listTracker
) {
return null;
}
const executionResult = operationExecutor.executeListOperations({
tracker: editorState.listTracker,
editorHost,
operations,
targetResolutionMode: 'api_uuid',
saveHistory: true,
afterSync: function() {
syncActiveListEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
structure: listTracker.getStructure(editorState.listTracker),
};
}
/**
* Apply one normalized structured edit payload to the active schema editor.
*
* This keeps non-list staged edits inside the same public runtime contract as
* list operations: open the editor first, then let FrontEdit own the mutation and
* history bookkeeping.
*
* @param {Object} options Structured-edit options.
* @returns {Object|null} Result summary for the applied edit.
*/
function applyStructuredEditToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const componentUpdates = Array.isArray(options.componentUpdates)
? options.componentUpdates.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const attributeOperations = Array.isArray(options.attributeOperations)
? options.attributeOperations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (!editorState || !editorHost || (!componentUpdates.length && !attributeOperations.length)) {
return null;
}
let attributeResult = null;
let componentResult = null;
if (
componentUpdates.length
&& operationExecutor
&& typeof operationExecutor.executeComponentOperations === 'function'
) {
componentResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations: componentUpdates,
saveHistory: false,
});
}
if (
attributeOperations.length &&
operationExecutor &&
typeof operationExecutor.executeBlockAttributeOperations === 'function'
) {
attributeResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations: attributeOperations,
saveHistory: false,
});
}
const didApplyAttributes = !!(
attributeResult &&
Array.isArray(attributeResult.operationsApplied) &&
attributeResult.operationsApplied.length
);
const didApplyComponents = !!(
componentResult &&
Array.isArray(componentResult.updatedComponentIds) &&
componentResult.updatedComponentIds.length
);
if (!didApplyComponents && !didApplyAttributes) {
return null;
}
syncActiveEditorState(editorState);
const historyApi = getSessionHistoryApiForHost(editorHost);
if (typeof historyApi?.saveToHistory === 'function') {
historyApi.saveToHistory();
}
if (typeof editorHost.updateToolbarState === 'function') {
editorHost.updateToolbarState();
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(componentResult?.updatedComponentIds)
? componentResult.updatedComponentIds
: [],
operationsApplied: [
...(Array.isArray(componentResult?.operationsApplied) ? componentResult.operationsApplied : []),
...(Array.isArray(attributeResult?.operationsApplied) ? attributeResult.operationsApplied : []),
],
attributeChanges: bridge.clonePlainData(editorHost.attributeChanges || {}),
};
}
/**
* Return a structural snapshot for one list block.
*
* This resolves against the live DOM so external tooling can inspect the
* current nested list tree without parsing serialized block markup itself.
*
* @param {Object} options Lookup options.
* @returns {Object|null} List structure snapshot.
*/
function getListStructure(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const listTracker = SFE.ListBlockTracker || null;
if (
!uuid ||
!(element instanceof Element) ||
!listTracker ||
(element.tagName !== 'UL' && element.tagName !== 'OL')
) {
return null;
}
const tracker = element._mwpListTracker
|| listTracker.init(element, resolveBlockState(uuid) || {});
return tracker && typeof listTracker.getStructure === 'function'
? listTracker.getStructure(tracker)
: null;
}
/**
* Apply one selected media item to the active schema-media editor session.
*
* This uses the same internal selection transition FrontEdit normally runs after
* the user picks an item from the media library or upload flow.
*
* @param {Object} options Media-selection options.
* @returns {Object|null} Stable editor snapshot after the selection is applied.
*/
function applyActiveMediaSelection(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim();
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
const editorHost = resolveActiveEditorHost(activeEditor);
const url = String(options.url || '').trim();
if (!editorHost || typeof editorHost.applyMediaSelection !== 'function' || !url) {
return null;
}
const attachmentId = Object.prototype.hasOwnProperty.call(options, 'attachmentId')
? options.attachmentId
: null;
const fromState = String(options.source || '').trim().toLowerCase() === 'library'
? 'library'
: 'input';
const didApply = editorHost.applyMediaSelection(url, attachmentId, { fromState });
return didApply === false ? null : buildEditorSnapshot(activeEditor);
}
/**
* Refresh one block through the supported server-rendered replacement path.
*
* @param {string} uuid Block UUID.
* @param {Object} [options={}] Refresh options.
* @returns {Promise} Refreshed block snapshot.
*/
async function refreshBlock(uuid, options = {}) {
const normalizedUuid = String(uuid || '').trim();
const element = getElementByUuid(normalizedUuid);
if (
!normalizedUuid ||
!(element instanceof Element) ||
!SFE.SaveHelpers ||
typeof SFE.SaveHelpers.fetchRenderedBlockHTML !== 'function' ||
!SFE.ElementUpdater ||
typeof SFE.ElementUpdater.applyNewHTML !== 'function'
) {
return null;
}
const html = await SFE.SaveHelpers.fetchRenderedBlockHTML(normalizedUuid, options || {});
if (!html) {
return null;
}
const newElement = SFE.ElementUpdater.applyNewHTML(element, normalizedUuid, html);
if (!newElement) {
return null;
}
if (typeof SFE.ElementUpdater.rebindElement === 'function') {
SFE.ElementUpdater.rebindElement(newElement);
}
const block = buildBlockSnapshot(normalizedUuid);
if (block) {
bridge.emitEvent('block:refreshed', {
source: String(options.source || 'sfe').trim() || 'sfe',
block,
});
}
return block;
}
/**
* Return one public dirty-block snapshot.
*
* @param {Object} entry Dirty entry from the batch manager.
* @returns {Object|null} Dirty block snapshot.
*/
function buildDirtyBlockSnapshot(entry) {
if (!entry || typeof entry !== 'object') {
return null;
}
return {
uuid: String(entry.element_uuid || '').trim(),
handlerId: String(entry.handler_id || '').trim(),
blockName: String(entry.blockName || '').trim(),
beforeRaw: String(entry.before || '').trim(),
afterRaw: String(entry.after || '').trim(),
};
}
/**
* Reset dirty batch state for one or more target UUIDs.
*
* @param {string[]} uuids Target UUIDs.
* @returns {boolean} Whether any batch state was reset.
*/
function resetDirtyBlocks(uuids) {
const batchManager = SFE.BatchEditManager || null;
const normalizedUuids = Array.isArray(uuids)
? uuids.map(uuid => String(uuid || '').trim()).filter(Boolean)
: [];
if (!normalizedUuids.length || !batchManager) {
return false;
}
if (typeof batchManager.resetDirtyBlocks === 'function') {
return !!batchManager.resetDirtyBlocks(normalizedUuids);
}
let changed = false;
normalizedUuids.forEach(uuid => {
if (batchManager.dirtyBlocks instanceof Map && batchManager.dirtyBlocks.has(uuid)) {
batchManager.dirtyBlocks.delete(uuid);
changed = true;
}
if (
batchManager.currentBlockStates instanceof Map &&
batchManager.baseBlockStates instanceof Map &&
batchManager.baseBlockStates.has(uuid)
) {
batchManager.currentBlockStates.set(
uuid,
bridge.clonePlainData(batchManager.baseBlockStates.get(uuid))
);
changed = true;
}
});
return changed;
}
/**
* Return the stable PublicApi discovery snapshot.
*
* @returns {Object} API metadata.
*/
function getApiInfo() {
return {
apiVersion: 1,
namespace: 'window.MWP.SFE.PublicApi',
features: {
editorControl: true,
runtimeInspection: true,
editableBlockDiscovery: true,
editingRuntimeResolution: true,
textComponentOperations: true,
mediaComponentOperations: true,
mediaInspection: true,
mediaSessionControl: true,
explicitStaging: true,
events: true,
blockRefresh: true,
},
};
}
PublicApi._buildEditorSnapshot = buildEditorSnapshot;
PublicApi.getApiInfo = getApiInfo;
PublicApi.isEditorOpen = function isEditorOpen() {
return !!getContext().activeEditor;
};
PublicApi.getActiveEditor = function getActiveEditor() {
return buildEditorSnapshot(getContext().activeEditor || null);
};
PublicApi.applyActiveMediaSelection = function applyActiveMediaSelectionPublic(options = {}) {
return applyActiveMediaSelection(options);
};
PublicApi.getPageContext = function getPageContext() {
const context = getContext();
const managerData = getManagerData();
return {
postId: Number(managerData.postId || 0) || 0,
permissions: bridge.clonePlainData(managerData.permissions || {}),
hasDraftPreview: !!(
document.body.classList.contains('mwp-sfe-active-preview') ||
context.activeMode === 'draft'
),
isEditorOpen: !!context.activeEditor,
activeMode: String(context.activeMode || '').trim(),
};
};
PublicApi.getRestContext = function getRestContext() {
const managerData = getManagerData();
return {
baseUrl: String(managerData.restBase || '').trim(),
namespaceUrl: String(managerData.restUrl || '').trim(),
nonce: String(managerData.nonce || '').trim(),
};
};
PublicApi.setRestNonce = function setRestNonce(nonce) {
const normalizedNonce = normalizeRestNonce(nonce);
if (!normalizedNonce) {
return PublicApi.getRestContext();
}
const managerData = getManagerData();
managerData.nonce = normalizedNonce;
SFE.ManagerData = managerData;
return PublicApi.getRestContext();
};
PublicApi.getElementByUuid = getElementByUuid;
PublicApi.getUuidForElement = getUuidForElement;
PublicApi.getBlockSnapshot = function getBlockSnapshot(uuid) {
return buildBlockSnapshot(uuid);
};
PublicApi.getEditableBlocks = getEditableBlocks;
PublicApi.resolveRuntime = function resolveRuntime(options = {}) {
return buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.resolveEditingRuntime = function resolveEditingRuntime(options = {}) {
return buildResolvedEditingRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.getEditableComponents = function getEditableComponents(options = {}) {
const runtime = buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
return runtime ? runtime.components : [];
};
PublicApi.getListStructure = getListStructure;
PublicApi.getDefaultComponent = function getDefaultComponent(options = {}) {
const components = PublicApi.getEditableComponents(options);
return components.find(component => component.default) || components[0] || null;
};
PublicApi.getMediaDescriptor = function getMediaDescriptor(options = {}) {
return resolveMediaDescriptor(options);
};
PublicApi.getMediaContext = function getMediaContext(options = {}) {
const descriptor = resolveMediaDescriptor(options);
const mediaHelper = SFE.MediaHelper || null;
if (!descriptor || !mediaHelper || typeof mediaHelper.getMediaType !== 'function') {
return null;
}
const mediaType = String(mediaHelper.getMediaType(descriptor) || '').trim();
if (!mediaType) {
return null;
}
return {
supported: true,
componentId: String(descriptor.componentId || '').trim(),
mediaType,
accept: typeof mediaHelper.getAcceptTypes === 'function'
? String(mediaHelper.getAcceptTypes(descriptor) || '*/*').trim() || '*/*'
: '*/*',
label: mediaType === 'audio' ? 'audio block' : (mediaType === 'video' ? 'video block' : (mediaType === 'file' ? 'file block' : 'media block')),
descriptor,
};
};
PublicApi.isMediaEditable = function isMediaEditable(options = {}) {
return !!PublicApi.getMediaContext(options);
};
PublicApi.openEditor = openEditor;
PublicApi.closeEditor = closeEditor;
PublicApi.applyTextComponentOperations = applyTextComponentOperationsToActiveEditor;
PublicApi.applyMediaComponentOperations = applyMediaComponentOperationsToActiveEditor;
PublicApi.applyBlockAttributeOperations = applyBlockAttributeOperationsToActiveEditor;
PublicApi.applyListOperations = applyListOperationsToActiveEditor;
PublicApi.applyStructuredEdit = applyStructuredEditToActiveEditor;
PublicApi.stageBlockState = function stageBlockState(stage) {
const uuid = String(stage && stage.uuid ? stage.uuid : '').trim();
if (!uuid || !stage || typeof stage !== 'object' || !stage.blockState || typeof stage.blockState !== 'object') {
return;
}
bridge.stagedBlockStates.set(uuid, {
handlerId: String(stage.handlerId || '').trim(),
source: String(stage.source || 'external').trim() || 'external',
blockState: bridge.clonePlainData(stage.blockState),
});
bridge.emitEvent('block:staged', {
source: String(stage.source || 'external').trim() || 'external',
uuid,
handlerId: String(stage.handlerId || '').trim(),
});
};
PublicApi.clearStagedBlockState = function clearStagedBlockState(uuid, source = 'external') {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid) {
return;
}
bridge.stagedBlockStates.delete(normalizedUuid);
bridge.emitEvent('block:stageCleared', {
source: String(source || 'external').trim() || 'external',
uuid: normalizedUuid,
});
};
PublicApi.refreshBlock = refreshBlock;
PublicApi.getDirtyBlocks = function getDirtyBlocks() {
const batchManager = SFE.BatchEditManager || null;
if (!batchManager || !(batchManager.dirtyBlocks instanceof Map)) {
return [];
}
return Array.from(batchManager.dirtyBlocks.values())
.map(buildDirtyBlockSnapshot)
.filter(entry => entry && entry.uuid);
};
PublicApi.hasDirtyBlocks = function hasDirtyBlocks() {
return PublicApi.getDirtyBlocks().length > 0;
};
PublicApi.isBatchSessionActive = function isBatchSessionActive() {
const batchManager = SFE.BatchEditManager || null;
return !!(
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive()
);
};
PublicApi.resetDirtyBlocks = function resetDirtyBlocksPublic(uuids) {
return resetDirtyBlocks(uuids);
};
SFE.PublicApi = PublicApi;
})();
/**
* Stable frontend runtime PublicApi implementation.
*
* Exposes: SFE.PublicApi
* {
* getApiInfo, on, off, isEditorOpen, getActiveEditor,
* applyActiveMediaSelection, getPageContext, getRestContext, setRestNonce,
* getElementByUuid, getUuidForElement, getBlockSnapshot, getEditableBlocks,
* resolveRuntime,
* resolveEditingRuntime, getEditableComponents, getListStructure,
* getDefaultComponent, getMediaDescriptor, getMediaContext,
* isMediaEditable, openEditor, closeEditor, applyTextComponentOperations,
* applyMediaComponentOperations,
* applyBlockAttributeOperations,
* applyListOperations, applyStructuredEdit, stageBlockState,
* clearStagedBlockState, refreshBlock, getDirtyBlocks, hasDirtyBlocks,
* isBatchSessionActive, resetDirtyBlocks
* }
*
* Keeps mutable runtime internals private while exposing the documented browser
* integration surface for external consumers such as ABE.
*/
(function() {
'use strict';
window.MWP = window.MWP || {};
window.MWP.SFE = window.MWP.SFE || {};
const SFE = window.MWP.SFE;
SFE.ManagerData = SFE.ManagerData || {};
const PublicApi = SFE.PublicApi || {};
const bridge = SFE.PublicApiBridge || null;
if (!bridge) {
return;
}
/**
* Resolve the shared runtime context object.
*
* @returns {Object} Shared FrontEdit context.
*/
function getContext() {
return SFE.Context || {};
}
/**
* Resolve the localized bootstrap payload.
*
* @returns {Object} Localized manager data.
*/
function getManagerData() {
return SFE.ManagerData || {};
}
/**
* Normalize one candidate REST nonce.
*
* @param {*} nonce Candidate nonce value.
* @returns {string} Trimmed nonce or an empty string.
*/
function normalizeRestNonce(nonce) {
return String(nonce || '').trim();
}
/**
* Return the live block element for one UUID.
*
* @param {string} uuid Block UUID.
* @returns {Element|null} Matching element.
*/
function getElementByUuid(uuid) {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || typeof document.querySelector !== 'function') {
return null;
}
try {
return document.querySelector(`[data-mwp-sfe-uuid="${CSS.escape(normalizedUuid)}"]`);
} catch (error) {
return document.querySelector(`[data-mwp-sfe-uuid="${normalizedUuid.replace(/"/g, '\\"')}"]`);
}
}
/**
* Resolve one UUID from a supplied element or nested child.
*
* @param {Element|null} element Candidate DOM node.
* @returns {string} Block UUID or an empty string.
*/
function getUuidForElement(element) {
if (!(element instanceof Element)) {
return '';
}
const candidate = element.closest('[data-mwp-sfe-uuid]');
return candidate instanceof Element
? String(candidate.getAttribute('data-mwp-sfe-uuid') || '').trim()
: '';
}
/**
* Resolve one uuid-map entry from the shared context.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} UUID map entry.
*/
function getUuidEntry(uuid) {
const context = getContext();
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid || !context.uuidMap || !context.uuidMap[normalizedUuid]) {
return null;
}
return context.uuidMap[normalizedUuid];
}
/**
* Resolve one edit-capable handler for the supplied target.
*
* @param {Object} options Resolution options.
* @returns {Object|null} Edit handler when supported.
*/
function resolveEditHandler(options = {}) {
const element = options.element instanceof Element ? options.element : null;
const preferredHandlerId = String(options.handlerId || '').trim();
const handlers = Array.isArray(element?._mwpSfeHandlers)
? element._mwpSfeHandlers
: [];
if (preferredHandlerId) {
const exact = handlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
));
if (exact) {
return exact;
}
}
const fromElement = handlers.find(handler => handler && handler.capability === 'edit') || null;
if (fromElement) {
return fromElement;
}
const uuidEntry = getUuidEntry(options.uuid);
const managerData = getManagerData();
const registeredHandlers = Array.isArray(managerData.handlers) ? managerData.handlers : [];
const handlerIds = Array.isArray(uuidEntry?.handlers) ? uuidEntry.handlers : [];
if (preferredHandlerId) {
return registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === preferredHandlerId
)) || null;
}
for (let index = 0; index < handlerIds.length; index++) {
const handlerId = String(handlerIds[index] || '').trim();
const match = registeredHandlers.find(handler => (
handler &&
handler.capability === 'edit' &&
handler.id === handlerId
));
if (match) {
return match;
}
}
return null;
}
/**
* Resolve the current block-state payload used for schema hydration.
*
* @param {string} uuid Block UUID.
* @returns {Object|null} Block-state payload when available.
*/
function resolveBlockState(uuid) {
const batchManager = SFE.BatchEditManager || null;
if (
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive() &&
typeof batchManager.getBlockStateForUuid === 'function'
) {
return batchManager.getBlockStateForUuid(uuid);
}
return null;
}
/**
* Resolve the schema runtime bundle for one target block.
*
* @param {Object} options Runtime resolution options.
* @returns {Object|null} Schema runtime bundle.
*/
function resolveRuntimeBundle(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const schemaRuntime = SFE.SchemaRuntime || null;
if (!uuid || !(element instanceof Element) || !handler || !schemaRuntime || typeof schemaRuntime.resolveForEditing !== 'function') {
return null;
}
try {
const blockState = options.blockState && typeof options.blockState === 'object'
? options.blockState
: resolveBlockState(uuid);
const attributeChanges = options.attributeChanges && typeof options.attributeChanges === 'object'
? options.attributeChanges
: undefined;
const resolved = schemaRuntime.resolveForEditing(element, handler, {
blockState,
attributeChanges,
});
if (!resolved || !resolved.runtimeHandler || !resolved.runtime) {
return null;
}
return {
uuid,
element,
handler: resolved.runtimeHandler,
runtime: resolved.runtime,
schema: resolved.schema || null,
};
} catch (error) {
console.warn('FrontEdit: PublicApi resolveRuntime failed', error);
return null;
}
}
/**
* Build one detailed editable-component snapshot from a schema runtime entry.
*
* @param {Object|null} editableComponent Runtime editable component.
* @param {Object|null} componentMeta Additional component metadata.
* @returns {Object|null} Detailed component snapshot.
*/
function buildEditingRuntimeComponentDetail(editableComponent, componentMeta = null) {
const snapshot = buildEditableComponentSnapshot(editableComponent);
if (!snapshot) {
return null;
}
const meta = componentMeta && typeof componentMeta === 'object' ? componentMeta : {};
snapshot.element = editableComponent?.element instanceof Element
? editableComponent.element
: (meta.element instanceof Element ? meta.element : null);
const bindings = Array.isArray(meta.bindings)
? bridge.clonePlainData(meta.bindings)
: [];
if (bindings.length) {
snapshot.bindings = bindings;
}
const target = meta.target && typeof meta.target === 'object'
? bridge.clonePlainData(meta.target)
: (snapshot.target || null);
if (target) {
snapshot.target = target;
}
const editorOptions = editableComponent?.editorOptions && typeof editableComponent.editorOptions === 'object'
? bridge.clonePlainData(editableComponent.editorOptions)
: (meta.editorOptions && typeof meta.editorOptions === 'object'
? bridge.clonePlainData(meta.editorOptions)
: null);
if (editorOptions) {
snapshot.editorOptions = editorOptions;
snapshot.editor = bridge.clonePlainData(editorOptions);
}
return snapshot;
}
/**
* Build one detailed schema-resolved editing runtime snapshot.
*
* This exposes the same resolved component metadata FrontEdit uses for editing
* while keeping handler resolution and schema runtime execution owned by FrontEdit.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Detailed editing runtime snapshot.
*/
function buildResolvedEditingRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const runtimeComponentsById = bundle.runtime.componentsById && typeof bundle.runtime.componentsById === 'object'
? bundle.runtime.componentsById
: {};
const componentDetails = [];
const componentsById = {};
(Array.isArray(bundle.runtime.editableComponents) ? bundle.runtime.editableComponents : []).forEach(component => {
const componentId = String(component?.id || '').trim();
const detail = buildEditingRuntimeComponentDetail(component, componentId ? runtimeComponentsById[componentId] : null);
if (!detail || !componentId) {
return;
}
componentDetails.push(detail);
componentsById[componentId] = detail;
});
Object.keys(runtimeComponentsById).forEach(componentId => {
if (componentsById[componentId]) {
return;
}
const detail = buildEditingRuntimeComponentDetail(runtimeComponentsById[componentId], runtimeComponentsById[componentId]);
if (!detail) {
return;
}
detail.id = componentId;
componentDetails.push(detail);
componentsById[componentId] = detail;
});
const mediaComponentId = String(bundle.runtime?.mediaComponent?.id || '').trim();
const mediaComponent = mediaComponentId && componentsById[mediaComponentId]
? componentsById[mediaComponentId]
: null;
return {
uuid: bundle.uuid,
element: bundle.element instanceof Element ? bundle.element : null,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
runtimeHandler: {
id: String(bundle.handler.id || '').trim(),
},
runtime: {
blockName: String(bundle.runtime.blockName || '').trim(),
editableComponents: componentDetails,
componentsById,
mediaComponent,
},
schema: {
handlerId: String(bundle.schema?.handlerId || bundle.handler.id || '').trim(),
},
};
}
/**
* Return a plain snapshot of one editable component.
*
* @param {Object|null} component Runtime component.
* @returns {Object|null} Public component snapshot.
*/
function buildEditableComponentSnapshot(component) {
if (!component || typeof component !== 'object') {
return null;
}
const snapshot = {
id: String(component.id || '').trim(),
label: String(component.label || component.id || '').trim(),
type: String(component.type || '').trim().toLowerCase(),
selector: String(component.selector || '').trim(),
default: !!component.default,
};
if (!snapshot.id || !snapshot.type) {
return null;
}
if (component.required === true) {
snapshot.required = true;
}
if (typeof component.placeholder === 'string' && component.placeholder.trim()) {
snapshot.placeholder = component.placeholder;
}
if (component.target && typeof component.target === 'object') {
snapshot.target = bridge.clonePlainData(component.target);
}
if (component.mediaDescriptor && typeof component.mediaDescriptor === 'object') {
snapshot.mediaDescriptor = bridge.clonePlainData(component.mediaDescriptor);
}
if (component.editorOptions && typeof component.editorOptions === 'object') {
snapshot.editor = bridge.clonePlainData(component.editorOptions);
}
return snapshot;
}
/**
* Resolve the public runtime mode label.
*
* @param {Object|null} runtime Schema runtime.
* @returns {string} Runtime mode label.
*/
function resolvePublicRuntimeMode(runtime) {
const components = Array.isArray(runtime?.editableComponents) ? runtime.editableComponents : [];
const hasText = components.some(component => String(component?.type || '').trim().toLowerCase() !== 'file');
const hasFile = components.some(component => String(component?.type || '').trim().toLowerCase() === 'file');
if (hasText && hasFile) {
return 'mixed';
}
if (hasFile) {
return 'file';
}
return 'text';
}
/**
* Build one public runtime snapshot from a schema bundle.
*
* @param {Object|null} bundle Runtime bundle.
* @returns {Object|null} Public runtime snapshot.
*/
function buildResolvedRuntimeSnapshot(bundle) {
if (!bundle || !bundle.runtime || !bundle.handler) {
return null;
}
const components = Array.isArray(bundle.runtime.editableComponents)
? bundle.runtime.editableComponents.map(buildEditableComponentSnapshot).filter(Boolean)
: [];
const defaultComponent = components.find(component => component.default) || components[0] || null;
return {
uuid: bundle.uuid,
handlerId: String(bundle.handler.id || '').trim(),
blockName: String(bundle.runtime.blockName || getUuidEntry(bundle.uuid)?.blockName || '').trim(),
schemaVersion: Number(bundle.schema?.version || 1) || 1,
mode: resolvePublicRuntimeMode(bundle.runtime),
defaultComponentId: defaultComponent ? defaultComponent.id : '',
components,
};
}
/**
* Resolve a public media descriptor for one target block.
*
* @param {Object} options Media resolution options.
* @returns {Object|null} Media descriptor snapshot.
*/
function resolveMediaDescriptor(options = {}) {
const runtime = resolveRuntimeBundle(options);
if (!runtime) {
return null;
}
const componentId = String(options.componentId || '').trim();
const components = Array.isArray(runtime.runtime.editableComponents) ? runtime.runtime.editableComponents : [];
const selected = componentId
? components.find(component => component && component.id === componentId)
: (
(runtime.runtime.mediaComponent && typeof runtime.runtime.mediaComponent === 'object'
? runtime.runtime.mediaComponent
: components.find(component => String(component?.type || '').trim().toLowerCase() === 'file')
) || null
);
if (!selected || !selected.mediaDescriptor || typeof selected.mediaDescriptor !== 'object') {
return null;
}
return bridge.clonePlainData(selected.mediaDescriptor);
}
/**
* Build one stable block snapshot.
*
* @param {string} uuid Target UUID.
* @returns {Object|null} Block snapshot.
*/
function buildBlockSnapshot(uuid) {
const normalizedUuid = String(uuid || '').trim();
const entry = getUuidEntry(normalizedUuid);
if (!normalizedUuid || !entry) {
return null;
}
return {
uuid: normalizedUuid,
blockName: String(entry.blockName || '').trim(),
handlerIds: Array.isArray(entry.handlers) ? entry.handlers.slice() : [],
isPending: !!entry.is_pending,
pendingInfo: entry.pending_info ? bridge.clonePlainData(entry.pending_info) : null,
elementPresent: !!getElementByUuid(normalizedUuid),
};
}
/**
* Return stable discovery snapshots for every editable block on this page.
*
* @returns {Array} Editable block snapshots in FrontEdit UUID-map order.
*/
function getEditableBlocks() {
const context = getContext();
const uuidMap = context.uuidMap && typeof context.uuidMap === 'object'
? context.uuidMap
: {};
return Object.keys(uuidMap)
.map(uuid => {
const snapshot = buildBlockSnapshot(uuid);
if (!snapshot) {
return null;
}
const element = getElementByUuid(uuid);
return {
...snapshot,
contentText: element instanceof Element
? String(element.textContent || '').replace(/\s+/g, ' ').trim()
: '',
};
})
.filter(Boolean);
}
/**
* Determine whether a block currently has tracked unsaved changes.
*
* @param {string} uuid Block UUID.
* @returns {boolean} Whether the block is dirty.
*/
function isDirtyUuid(uuid) {
const batchManager = SFE.BatchEditManager || null;
return !!(
uuid &&
batchManager &&
batchManager.dirtyBlocks instanceof Map &&
batchManager.dirtyBlocks.has(uuid)
);
}
/**
* Build one public editor snapshot from a live editor state object.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object|null} Stable editor snapshot.
*/
function buildEditorSnapshot(editorState) {
if (!editorState || !editorState.uuid) {
return null;
}
const draftEditState = getContext().draftEditState;
const isDraftSession = !!(
draftEditState &&
draftEditState.draftElement &&
draftEditState.draftElement === editorState.element
);
const activeComponentId = String(
editorState.activeComponentId
|| editorState.activeEditableComponent?.id
|| ''
).trim();
const activeComponentType = String(
editorState._mwpActiveComponentType
|| editorState.activeEditableComponent?.type
|| (editorState.isMediaEditor ? 'file' : 'text')
).trim().toLowerCase();
const activeEditorHost = resolveActiveEditorHost(editorState);
return {
uuid: String(editorState.uuid || '').trim(),
handlerId: String(editorState._mwpSchemaHandlerId || editorState.handler?.id || '').trim(),
mode: String(editorState.requestedMode || (isDraftSession ? 'draft' : 'edit')).trim() || 'edit',
blockName: String(editorState.blockName || editorState.blockState?.blockName || '').trim(),
isOpen: true,
componentType: activeComponentType || 'text',
componentId: activeComponentId,
saveStrategy: String(editorState.saveStrategy || 'single').trim() || 'single',
hasMediaSession: typeof activeEditorHost?.applyMediaSelection === 'function',
isDirty: isDirtyUuid(editorState.uuid),
isDraftSession,
isBatchSession: !!(
editorState.saveStrategy === 'batch' &&
SFE.BatchEditManager &&
typeof SFE.BatchEditManager.isSessionActive === 'function' &&
SFE.BatchEditManager.isSessionActive()
),
};
}
/**
* Switch the active editable component inside one open editor session.
*
* @param {Object} editorState Active editor state.
* @param {string} componentId Target component identifier.
* @returns {boolean} Whether the switch succeeded.
*/
function activateEditorComponent(editorState, componentId) {
if (!editorState || !componentId) {
return false;
}
if (SFE.TextEditor && typeof SFE.TextEditor.activateEditableComponentById === 'function') {
return !!SFE.TextEditor.activateEditableComponentById(editorState, componentId);
}
return false;
}
/**
* Open one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Open-editor options.
* @returns {Promise} Editor snapshot after opening.
*/
async function openEditor(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const handler = resolveEditHandler({
uuid,
element,
handlerId: options.handlerId,
});
const componentId = String(options.componentId || '').trim();
if (!uuid || !(element instanceof Element) || !handler || typeof SFE.startEditing !== 'function') {
return null;
}
const activeEditor = getContext().activeEditor || null;
if (activeEditor && String(activeEditor.uuid || '').trim() === uuid) {
if (componentId) {
activateEditorComponent(activeEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || activeEditor);
}
if (activeEditor && typeof SFE.closeInPlaceEditor === 'function') {
SFE.closeInPlaceEditor(activeEditor, true, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
});
}
await Promise.resolve(
SFE.startEditing(
element,
handler,
uuid,
null,
false,
String(options.mode || 'edit').trim() || 'edit',
{
initialComponentId: componentId,
source: String(options.source || 'external').trim() || 'external',
originalSnapshots: options.originalSnapshots && typeof options.originalSnapshots === 'object'
? {
restoreOuterHTML: String(options.originalSnapshots.restoreOuterHTML || '').trim(),
cleanOuterHTML: String(options.originalSnapshots.cleanOuterHTML || '').trim(),
}
: null,
}
)
);
const openedEditor = getContext().activeEditor || null;
if (openedEditor && componentId) {
activateEditorComponent(openedEditor, componentId);
}
return buildEditorSnapshot(getContext().activeEditor || openedEditor);
}
/**
* Close one editor session through the supported FrontEdit runtime path.
*
* @param {Object} options Close-editor options.
* @returns {boolean} Whether a close was attempted.
*/
function closeEditor(options = {}) {
const activeEditor = getContext().activeEditor || null;
if (!activeEditor || typeof SFE.closeInPlaceEditor !== 'function') {
return false;
}
const targetUuid = String(options.uuid || '').trim();
if (targetUuid && String(activeEditor.uuid || '').trim() !== targetUuid) {
return false;
}
return SFE.closeInPlaceEditor(activeEditor, options.restoreOriginal !== false, {
closeReason: String(options.reason || 'api').trim() || 'api',
source: String(options.source || 'external').trim() || 'external',
}) !== false;
}
/**
* Resolve the active editor state for one target block UUID.
*
* Schema-backed editor operations intentionally require a live open editor so
* the DOM mutation stays inside the same save/history session FrontEdit owns.
*
* @param {Object} options Editor-operation options.
* @returns {Object|null} Active editor state.
*/
function resolveActiveEditorState(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
return resolveActiveEditorHost(activeEditor) ? activeEditor : null;
}
function resolveActiveEditorHost(editorState) {
return SFE.SchemaEditorHost?.resolveActiveEditorHost?.(editorState) || null;
}
/**
* Resolve the session-owned history API for one active editor host.
*
* External runtime mutations should commit through the same shared block
* session contract used internally instead of reaching into ad hoc
* editor-state history fields.
*
* @param {Object|null} editorHost Active schema editor host.
* @returns {Object|null} Session history API, or null when unavailable.
*/
function getSessionHistoryApiForHost(editorHost) {
if (editorHost?.historyApi && typeof editorHost.historyApi === 'object') {
return editorHost.historyApi;
}
if (typeof editorHost?.getSessionHistoryApi === 'function') {
return editorHost.getSessionHistoryApi();
}
const blockEditSession = editorHost?.blockEditSession || null;
if (!blockEditSession || typeof blockEditSession.getHistoryApi !== 'function') {
return null;
}
return blockEditSession.getHistoryApi(
String(editorHost?.blockEditSessionScopeId || '').trim() || 'text'
);
}
/**
* Refresh one active editor state after a schema-driven DOM mutation.
*
* @param {Object} editorState Active editor state.
* @returns {void}
*/
function syncActiveEditorState(editorState) {
if (!editorState?.handler) {
return;
}
const editorHost = resolveActiveEditorHost(editorState);
const blockRootElement = (
editorHost &&
typeof editorHost.getBlockRootElement === 'function'
)
? editorHost.getBlockRootElement()
: null;
if (blockRootElement && blockRootElement !== editorState.element) {
// The active schema host element can be one editable component (for
// example, one table cell), while block-session history and restore must
// keep targeting the outer block root. Rebasing `editorState.element` to
// the component host corrupts undo/redo by replaying full block markup
// into that component instead of the block wrapper.
editorState.element = blockRootElement;
}
if (!editorState.element) {
return;
}
const schemaRuntime = SFE.SchemaRuntime || null;
if (
schemaRuntime &&
typeof schemaRuntime.syncPlaceholders === 'function'
) {
schemaRuntime.syncPlaceholders(editorState.element, editorState.handler, {
blockAttributes: editorState.blockState?.attrs || null,
attributeChanges: editorState.attributeChanges || null,
});
}
if (
SFE.TextEditor &&
typeof SFE.TextEditor.refreshEditableComponents === 'function'
) {
SFE.TextEditor.refreshEditableComponents(editorState);
}
}
/**
* Build one component map for the active schema editor state.
*
* @param {Object|null} editorState Active editor state.
* @returns {Object} Editable components keyed by ID.
*/
function getActiveEditorComponentMap(editorState) {
if (!editorState || !Array.isArray(editorState.editableComponents)) {
return {};
}
return editorState.editableComponents.reduce((map, component) => {
const componentId = String(component?.id || '').trim();
if (!componentId || !component?.element) {
return map;
}
map[componentId] = component;
return map;
}, {});
}
/**
* Return the lowercase host tag name for one candidate component element.
*
* @param {Element|null} hostElement Candidate host element.
* @returns {string} Lowercase host tag name.
*/
function getHostElementTagName(hostElement) {
return hostElement && hostElement.tagName
? String(hostElement.tagName || '').trim().toLowerCase()
: '';
}
/**
* Build one inline format wrapper for a structured run token.
*
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {string} formatToken Format token.
* @param {Object|null} formatAttributes Optional format attributes.
* @returns {HTMLElement|null} Wrapper element.
*/
function buildStructuredFormatWrapper(inlineCapabilities, formatToken, formatAttributes = null) {
const tagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!tagName) {
return null;
}
const element = document.createElement(tagName);
if (tagName === 'a' && formatAttributes && typeof formatAttributes === 'object') {
const href = String(formatAttributes.href || '').trim();
if (href) {
element.setAttribute('href', href);
}
const target = String(formatAttributes.target || '').trim();
if (target) {
element.setAttribute('target', target);
}
const rel = String(formatAttributes.rel || '').trim();
if (rel) {
element.setAttribute('rel', rel);
}
}
return element;
}
/**
* Hoist same-tag inline format attributes onto the host component element.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Element|null} hostElement Live host element.
* @returns {{runs: Array, hostAttributes: Object}} Hoisted run data.
*/
function hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement = null) {
const hostTagName = getHostElementTagName(hostElement);
if (!hostTagName) {
return {
runs: Array.isArray(runs) ? runs : [],
hostAttributes: {},
};
}
const hostAttributes = {};
const normalizedRuns = (Array.isArray(runs) ? runs : []).map(run => {
const formats = Array.isArray(run?.formats) ? run.formats : [];
const formatAttributes = run?.formatAttributes && typeof run.formatAttributes === 'object'
? { ...run.formatAttributes }
: {};
const nextFormats = [];
formats.forEach(formatToken => {
const formatTagName = String(inlineCapabilities?.[formatToken]?.tag || '').trim().toLowerCase();
if (!formatTagName || formatTagName !== hostTagName) {
nextFormats.push(formatToken);
return;
}
const attributes = formatAttributes?.[formatToken];
if (attributes && typeof attributes === 'object' && !Array.isArray(attributes)) {
Object.assign(hostAttributes, attributes);
}
delete formatAttributes[formatToken];
});
return {
...run,
formats: nextFormats,
formatAttributes,
};
});
return {
runs: normalizedRuns,
hostAttributes,
};
}
/**
* Apply hoisted inline-format attributes onto one host element.
*
* @param {Element|null} hostElement Live host element.
* @param {Object|null} hostAttributes Hoisted host attributes.
* @returns {void}
*/
function applyStructuredHostLevelFormatAttributes(hostElement, hostAttributes = null) {
if (!hostElement || typeof hostElement.setAttribute !== 'function' || typeof hostElement.removeAttribute !== 'function') {
return;
}
const attributes = hostAttributes && typeof hostAttributes === 'object' ? hostAttributes : {};
['href', 'target', 'rel'].forEach(attributeName => {
const value = typeof attributes[attributeName] === 'string'
? attributes[attributeName].trim()
: '';
if (value) {
hostElement.setAttribute(attributeName, value);
return;
}
hostElement.removeAttribute(attributeName);
});
}
/**
* Build deterministic HTML from one normalized structured run sequence.
*
* @param {Array} runs Structured text runs.
* @param {Object} inlineCapabilities Allowed inline format capability map.
* @param {Object} editorOptions Runtime editor options.
* @param {Element|null} hostElement Live host element.
* @returns {{html: string, hostAttributes: Object}} Rendered HTML fragment.
*/
function buildStructuredHtmlFromRuns(runs, inlineCapabilities, editorOptions = {}, hostElement = null) {
const container = document.createElement('div');
const extractionOptions = editorOptions?.options && typeof editorOptions.options === 'object'
? editorOptions.options
: {};
const hoisted = hoistStructuredHostLevelFormats(runs, inlineCapabilities, hostElement);
(Array.isArray(hoisted.runs) ? hoisted.runs : []).forEach(run => {
const text = String(run?.text || '');
if (!text) {
return;
}
const segments = extractionOptions.newlinesToBR === true || String(editorOptions?.enterMode || '').trim() === 'linebreak'
? text.split('\n')
: [text];
segments.forEach((segment, index) => {
if (index > 0) {
container.appendChild(document.createElement('br'));
}
if (!segment) {
return;
}
let node = document.createTextNode(segment);
(Array.isArray(run.formats) ? run.formats : []).forEach(formatToken => {
const wrapper = buildStructuredFormatWrapper(
inlineCapabilities,
formatToken,
run.formatAttributes && typeof run.formatAttributes === 'object'
? run.formatAttributes[formatToken] || null
: null
);
if (!wrapper) {
return;
}
wrapper.appendChild(node);
node = wrapper;
});
container.appendChild(node);
});
});
return {
html: container.innerHTML,
hostAttributes: hoisted.hostAttributes,
};
}
/**
* Apply structured component updates onto the active editor DOM.
*
* @param {Object} editorState Active editor state.
* @param {Array} componentUpdates Normalized component updates.
* @returns {string[]} Updated component IDs.
*/
function applyStructuredComponentUpdates(editorState, componentUpdates) {
const componentMap = getActiveEditorComponentMap(editorState);
const updatedComponentIds = [];
(Array.isArray(componentUpdates) ? componentUpdates : []).forEach(componentUpdate => {
const componentId = String(componentUpdate?.componentId || '').trim();
const component = componentMap[componentId] || null;
if (!component || !component.element) {
return;
}
if (componentUpdate.bindingSource === 'plaintext') {
component.element.textContent = (Array.isArray(componentUpdate.runs) ? componentUpdate.runs : [])
.map(run => String(run?.text || ''))
.join('');
updatedComponentIds.push(componentId);
return;
}
if (componentUpdate.bindingSource === 'html') {
const rendered = buildStructuredHtmlFromRuns(
componentUpdate.runs,
componentUpdate.inlineCapabilities || {},
componentUpdate.editorOptions || component.editorOptions || {},
component.element
);
component.element.innerHTML = rendered.html;
applyStructuredHostLevelFormatAttributes(component.element, rendered.hostAttributes);
updatedComponentIds.push(componentId);
}
});
return Array.from(new Set(updatedComponentIds));
}
/**
* Resolve the active list-editor state for one target block UUID.
*
* Structural list operations intentionally require a live open editor so the
* mutation happens inside the same DOM/save session FrontEdit already owns.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Active list editor state.
*/
function resolveActiveListEditorState(options = {}) {
const activeEditor = resolveActiveEditorState(options);
if (!activeEditor) {
return null;
}
const listTracker = SFE.ListBlockTracker || null;
if (
!listTracker ||
!activeEditor.element ||
(activeEditor.element.tagName !== 'UL' && activeEditor.element.tagName !== 'OL')
) {
return null;
}
if (!activeEditor.listTracker || activeEditor.listTracker.listElement !== activeEditor.element) {
activeEditor.listTracker = listTracker.init(
activeEditor.element,
activeEditor.blockState || {}
);
}
return activeEditor.listTracker ? activeEditor : null;
}
/**
* Refresh one active list editor after a structural DOM mutation.
*
* @param {Object} editorState Active list editor state.
* @returns {void}
*/
function syncActiveListEditorState(editorState) {
if (!editorState?.element || !editorState?.handler) {
return;
}
if (editorState.listTracker?.listElement && editorState.listTracker.listElement !== editorState.element) {
editorState.element = editorState.listTracker.listElement;
const editorHost = resolveActiveEditorHost(editorState);
if (editorHost && typeof editorHost === 'object') {
editorHost.element = editorState.listTracker.listElement;
}
}
syncActiveEditorState(editorState);
}
/**
* Apply one or more schema-declared block-attribute operations to the active editor.
*
* @param {Object} options Block-attribute operation options.
* @returns {Object|null} Result summary and current tracked attribute changes.
*/
function applyBlockAttributeOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeBlockAttributeOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
attributeChanges: bridge.clonePlainData(executionResult.attributeChanges || {}),
};
}
/**
* Apply one or more component-content replacement operations to the active editor.
*
* The shared executor owns rich-text run rendering and link normalization so
* external callers can target component surfaces without reimplementing FrontEdit's
* browser mutation semantics.
*
* @param {Object} options Component-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyTextComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeComponentOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations,
saveHistory: true,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more schema-backed media replacements to the active editor.
*
* This targets the currently active media-session host so external callers
* can replace schema media components without bypassing FrontEdit's own preview and
* resolved-media update pipeline.
*
* @param {Object} options Media-operation options.
* @returns {Object|null} Result summary and updated component IDs.
*/
function applyMediaComponentOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeMediaOperations !== 'function'
) {
return null;
}
const executionResult = operationExecutor.executeMediaOperations({
editorState,
editorHost,
operations,
afterSync: function() {
syncActiveEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(executionResult.updatedComponentIds)
? executionResult.updatedComponentIds.slice()
: [],
operationsApplied: Array.isArray(executionResult.operationsApplied)
? executionResult.operationsApplied.slice()
: [],
};
}
/**
* Apply one or more high-level public list operations to the currently open
* list editor.
*
* The runtime API accepts UUID-oriented public commands and lets the shared
* executor translate them into the internal primitive tracker operations.
*
* @param {Object} options List-operation options.
* @returns {Object|null} Result summary and next list structure.
*/
function applyListOperationsToActiveEditor(options = {}) {
const editorState = resolveActiveListEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const operations = Array.isArray(options.operations)
? options.operations
: (options.operation ? [ options.operation ] : []);
const operationExecutor = SFE.SchemaOperationExecutor || null;
const listTracker = SFE.ListBlockTracker || null;
if (
!editorState ||
!editorHost ||
!operations.length ||
!operationExecutor ||
typeof operationExecutor.executeListOperations !== 'function' ||
!listTracker
) {
return null;
}
const executionResult = operationExecutor.executeListOperations({
tracker: editorState.listTracker,
editorHost,
operations,
targetResolutionMode: 'api_uuid',
saveHistory: true,
afterSync: function() {
syncActiveListEditorState(editorState);
},
});
if (!executionResult) {
return null;
}
return {
uuid: String(editorState.uuid || '').trim(),
operationsApplied: executionResult.operationsApplied,
structure: listTracker.getStructure(editorState.listTracker),
};
}
/**
* Apply one normalized structured edit payload to the active schema editor.
*
* This keeps non-list staged edits inside the same public runtime contract as
* list operations: open the editor first, then let FrontEdit own the mutation and
* history bookkeeping.
*
* @param {Object} options Structured-edit options.
* @returns {Object|null} Result summary for the applied edit.
*/
function applyStructuredEditToActiveEditor(options = {}) {
const editorState = resolveActiveEditorState(options);
const editorHost = resolveActiveEditorHost(editorState);
const componentUpdates = Array.isArray(options.componentUpdates)
? options.componentUpdates.filter(operation => operation && typeof operation === 'object' && !Array.isArray(operation))
: [];
const attributeOperations = Array.isArray(options.attributeOperations)
? options.attributeOperations.filter(operation => (
operation &&
typeof operation === 'object' &&
!Array.isArray(operation) &&
typeof operation.id === 'string' &&
operation.id.trim() &&
Object.prototype.hasOwnProperty.call(operation, 'value')
))
: [];
const operationExecutor = SFE.SchemaOperationExecutor || null;
if (!editorState || !editorHost || (!componentUpdates.length && !attributeOperations.length)) {
return null;
}
let attributeResult = null;
let componentResult = null;
if (
componentUpdates.length
&& operationExecutor
&& typeof operationExecutor.executeComponentOperations === 'function'
) {
componentResult = operationExecutor.executeComponentOperations({
editorState,
editorHost,
operations: componentUpdates,
saveHistory: false,
});
}
if (
attributeOperations.length &&
operationExecutor &&
typeof operationExecutor.executeBlockAttributeOperations === 'function'
) {
attributeResult = operationExecutor.executeBlockAttributeOperations({
editorHost,
operations: attributeOperations,
saveHistory: false,
});
}
const didApplyAttributes = !!(
attributeResult &&
Array.isArray(attributeResult.operationsApplied) &&
attributeResult.operationsApplied.length
);
const didApplyComponents = !!(
componentResult &&
Array.isArray(componentResult.updatedComponentIds) &&
componentResult.updatedComponentIds.length
);
if (!didApplyComponents && !didApplyAttributes) {
return null;
}
syncActiveEditorState(editorState);
const historyApi = getSessionHistoryApiForHost(editorHost);
if (typeof historyApi?.saveToHistory === 'function') {
historyApi.saveToHistory();
}
if (typeof editorHost.updateToolbarState === 'function') {
editorHost.updateToolbarState();
}
return {
uuid: String(editorState.uuid || '').trim(),
updatedComponentIds: Array.isArray(componentResult?.updatedComponentIds)
? componentResult.updatedComponentIds
: [],
operationsApplied: [
...(Array.isArray(componentResult?.operationsApplied) ? componentResult.operationsApplied : []),
...(Array.isArray(attributeResult?.operationsApplied) ? attributeResult.operationsApplied : []),
],
attributeChanges: bridge.clonePlainData(editorHost.attributeChanges || {}),
};
}
/**
* Return a structural snapshot for one list block.
*
* This resolves against the live DOM so external tooling can inspect the
* current nested list tree without parsing serialized block markup itself.
*
* @param {Object} options Lookup options.
* @returns {Object|null} List structure snapshot.
*/
function getListStructure(options = {}) {
const uuid = String(options.uuid || '').trim() || getUuidForElement(options.element);
const element = options.element instanceof Element ? options.element : getElementByUuid(uuid);
const listTracker = SFE.ListBlockTracker || null;
if (
!uuid ||
!(element instanceof Element) ||
!listTracker ||
(element.tagName !== 'UL' && element.tagName !== 'OL')
) {
return null;
}
const tracker = element._mwpListTracker
|| listTracker.init(element, resolveBlockState(uuid) || {});
return tracker && typeof listTracker.getStructure === 'function'
? listTracker.getStructure(tracker)
: null;
}
/**
* Apply one selected media item to the active schema-media editor session.
*
* This uses the same internal selection transition FrontEdit normally runs after
* the user picks an item from the media library or upload flow.
*
* @param {Object} options Media-selection options.
* @returns {Object|null} Stable editor snapshot after the selection is applied.
*/
function applyActiveMediaSelection(options = {}) {
const activeEditor = getContext().activeEditor || null;
const targetUuid = String(options.uuid || '').trim();
if (!activeEditor || !targetUuid || String(activeEditor.uuid || '').trim() !== targetUuid) {
return null;
}
const editorHost = resolveActiveEditorHost(activeEditor);
const url = String(options.url || '').trim();
if (!editorHost || typeof editorHost.applyMediaSelection !== 'function' || !url) {
return null;
}
const attachmentId = Object.prototype.hasOwnProperty.call(options, 'attachmentId')
? options.attachmentId
: null;
const fromState = String(options.source || '').trim().toLowerCase() === 'library'
? 'library'
: 'input';
const didApply = editorHost.applyMediaSelection(url, attachmentId, { fromState });
return didApply === false ? null : buildEditorSnapshot(activeEditor);
}
/**
* Refresh one block through the supported server-rendered replacement path.
*
* @param {string} uuid Block UUID.
* @param {Object} [options={}] Refresh options.
* @returns {Promise} Refreshed block snapshot.
*/
async function refreshBlock(uuid, options = {}) {
const normalizedUuid = String(uuid || '').trim();
const element = getElementByUuid(normalizedUuid);
if (
!normalizedUuid ||
!(element instanceof Element) ||
!SFE.SaveHelpers ||
typeof SFE.SaveHelpers.fetchRenderedBlockHTML !== 'function' ||
!SFE.ElementUpdater ||
typeof SFE.ElementUpdater.applyNewHTML !== 'function'
) {
return null;
}
const html = await SFE.SaveHelpers.fetchRenderedBlockHTML(normalizedUuid, options || {});
if (!html) {
return null;
}
const newElement = SFE.ElementUpdater.applyNewHTML(element, normalizedUuid, html);
if (!newElement) {
return null;
}
if (typeof SFE.ElementUpdater.rebindElement === 'function') {
SFE.ElementUpdater.rebindElement(newElement);
}
const block = buildBlockSnapshot(normalizedUuid);
if (block) {
bridge.emitEvent('block:refreshed', {
source: String(options.source || 'sfe').trim() || 'sfe',
block,
});
}
return block;
}
/**
* Return one public dirty-block snapshot.
*
* @param {Object} entry Dirty entry from the batch manager.
* @returns {Object|null} Dirty block snapshot.
*/
function buildDirtyBlockSnapshot(entry) {
if (!entry || typeof entry !== 'object') {
return null;
}
return {
uuid: String(entry.element_uuid || '').trim(),
handlerId: String(entry.handler_id || '').trim(),
blockName: String(entry.blockName || '').trim(),
beforeRaw: String(entry.before || '').trim(),
afterRaw: String(entry.after || '').trim(),
};
}
/**
* Reset dirty batch state for one or more target UUIDs.
*
* @param {string[]} uuids Target UUIDs.
* @returns {boolean} Whether any batch state was reset.
*/
function resetDirtyBlocks(uuids) {
const batchManager = SFE.BatchEditManager || null;
const normalizedUuids = Array.isArray(uuids)
? uuids.map(uuid => String(uuid || '').trim()).filter(Boolean)
: [];
if (!normalizedUuids.length || !batchManager) {
return false;
}
if (typeof batchManager.resetDirtyBlocks === 'function') {
return !!batchManager.resetDirtyBlocks(normalizedUuids);
}
let changed = false;
normalizedUuids.forEach(uuid => {
if (batchManager.dirtyBlocks instanceof Map && batchManager.dirtyBlocks.has(uuid)) {
batchManager.dirtyBlocks.delete(uuid);
changed = true;
}
if (
batchManager.currentBlockStates instanceof Map &&
batchManager.baseBlockStates instanceof Map &&
batchManager.baseBlockStates.has(uuid)
) {
batchManager.currentBlockStates.set(
uuid,
bridge.clonePlainData(batchManager.baseBlockStates.get(uuid))
);
changed = true;
}
});
return changed;
}
/**
* Return the stable PublicApi discovery snapshot.
*
* @returns {Object} API metadata.
*/
function getApiInfo() {
return {
apiVersion: 1,
namespace: 'window.MWP.SFE.PublicApi',
features: {
editorControl: true,
runtimeInspection: true,
editableBlockDiscovery: true,
editingRuntimeResolution: true,
textComponentOperations: true,
mediaComponentOperations: true,
mediaInspection: true,
mediaSessionControl: true,
explicitStaging: true,
events: true,
blockRefresh: true,
},
};
}
PublicApi._buildEditorSnapshot = buildEditorSnapshot;
PublicApi.getApiInfo = getApiInfo;
PublicApi.isEditorOpen = function isEditorOpen() {
return !!getContext().activeEditor;
};
PublicApi.getActiveEditor = function getActiveEditor() {
return buildEditorSnapshot(getContext().activeEditor || null);
};
PublicApi.applyActiveMediaSelection = function applyActiveMediaSelectionPublic(options = {}) {
return applyActiveMediaSelection(options);
};
PublicApi.getPageContext = function getPageContext() {
const context = getContext();
const managerData = getManagerData();
return {
postId: Number(managerData.postId || 0) || 0,
permissions: bridge.clonePlainData(managerData.permissions || {}),
hasDraftPreview: !!(
document.body.classList.contains('mwp-sfe-active-preview') ||
context.activeMode === 'draft'
),
isEditorOpen: !!context.activeEditor,
activeMode: String(context.activeMode || '').trim(),
};
};
PublicApi.getRestContext = function getRestContext() {
const managerData = getManagerData();
return {
baseUrl: String(managerData.restBase || '').trim(),
namespaceUrl: String(managerData.restUrl || '').trim(),
nonce: String(managerData.nonce || '').trim(),
};
};
PublicApi.setRestNonce = function setRestNonce(nonce) {
const normalizedNonce = normalizeRestNonce(nonce);
if (!normalizedNonce) {
return PublicApi.getRestContext();
}
const managerData = getManagerData();
managerData.nonce = normalizedNonce;
SFE.ManagerData = managerData;
return PublicApi.getRestContext();
};
PublicApi.getElementByUuid = getElementByUuid;
PublicApi.getUuidForElement = getUuidForElement;
PublicApi.getBlockSnapshot = function getBlockSnapshot(uuid) {
return buildBlockSnapshot(uuid);
};
PublicApi.getEditableBlocks = getEditableBlocks;
PublicApi.resolveRuntime = function resolveRuntime(options = {}) {
return buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.resolveEditingRuntime = function resolveEditingRuntime(options = {}) {
return buildResolvedEditingRuntimeSnapshot(resolveRuntimeBundle(options));
};
PublicApi.getEditableComponents = function getEditableComponents(options = {}) {
const runtime = buildResolvedRuntimeSnapshot(resolveRuntimeBundle(options));
return runtime ? runtime.components : [];
};
PublicApi.getListStructure = getListStructure;
PublicApi.getDefaultComponent = function getDefaultComponent(options = {}) {
const components = PublicApi.getEditableComponents(options);
return components.find(component => component.default) || components[0] || null;
};
PublicApi.getMediaDescriptor = function getMediaDescriptor(options = {}) {
return resolveMediaDescriptor(options);
};
PublicApi.getMediaContext = function getMediaContext(options = {}) {
const descriptor = resolveMediaDescriptor(options);
const mediaHelper = SFE.MediaHelper || null;
if (!descriptor || !mediaHelper || typeof mediaHelper.getMediaType !== 'function') {
return null;
}
const mediaType = String(mediaHelper.getMediaType(descriptor) || '').trim();
if (!mediaType) {
return null;
}
return {
supported: true,
componentId: String(descriptor.componentId || '').trim(),
mediaType,
accept: typeof mediaHelper.getAcceptTypes === 'function'
? String(mediaHelper.getAcceptTypes(descriptor) || '*/*').trim() || '*/*'
: '*/*',
label: mediaType === 'audio' ? 'audio block' : (mediaType === 'video' ? 'video block' : (mediaType === 'file' ? 'file block' : 'media block')),
descriptor,
};
};
PublicApi.isMediaEditable = function isMediaEditable(options = {}) {
return !!PublicApi.getMediaContext(options);
};
PublicApi.openEditor = openEditor;
PublicApi.closeEditor = closeEditor;
PublicApi.applyTextComponentOperations = applyTextComponentOperationsToActiveEditor;
PublicApi.applyMediaComponentOperations = applyMediaComponentOperationsToActiveEditor;
PublicApi.applyBlockAttributeOperations = applyBlockAttributeOperationsToActiveEditor;
PublicApi.applyListOperations = applyListOperationsToActiveEditor;
PublicApi.applyStructuredEdit = applyStructuredEditToActiveEditor;
PublicApi.stageBlockState = function stageBlockState(stage) {
const uuid = String(stage && stage.uuid ? stage.uuid : '').trim();
if (!uuid || !stage || typeof stage !== 'object' || !stage.blockState || typeof stage.blockState !== 'object') {
return;
}
bridge.stagedBlockStates.set(uuid, {
handlerId: String(stage.handlerId || '').trim(),
source: String(stage.source || 'external').trim() || 'external',
blockState: bridge.clonePlainData(stage.blockState),
});
bridge.emitEvent('block:staged', {
source: String(stage.source || 'external').trim() || 'external',
uuid,
handlerId: String(stage.handlerId || '').trim(),
});
};
PublicApi.clearStagedBlockState = function clearStagedBlockState(uuid, source = 'external') {
const normalizedUuid = String(uuid || '').trim();
if (!normalizedUuid) {
return;
}
bridge.stagedBlockStates.delete(normalizedUuid);
bridge.emitEvent('block:stageCleared', {
source: String(source || 'external').trim() || 'external',
uuid: normalizedUuid,
});
};
PublicApi.refreshBlock = refreshBlock;
PublicApi.getDirtyBlocks = function getDirtyBlocks() {
const batchManager = SFE.BatchEditManager || null;
if (!batchManager || !(batchManager.dirtyBlocks instanceof Map)) {
return [];
}
return Array.from(batchManager.dirtyBlocks.values())
.map(buildDirtyBlockSnapshot)
.filter(entry => entry && entry.uuid);
};
PublicApi.hasDirtyBlocks = function hasDirtyBlocks() {
return PublicApi.getDirtyBlocks().length > 0;
};
PublicApi.isBatchSessionActive = function isBatchSessionActive() {
const batchManager = SFE.BatchEditManager || null;
return !!(
batchManager &&
typeof batchManager.isSessionActive === 'function' &&
batchManager.isSessionActive()
);
};
PublicApi.resetDirtyBlocks = function resetDirtyBlocksPublic(uuids) {
return resetDirtyBlocks(uuids);
};
SFE.PublicApi = PublicApi;
})();
