import { nodeToTree } from "@html_editor/core/history_plugin";
import { Plugin } from "@html_editor/plugin";
import { withSequence } from "@html_editor/utils/resource";
import { memoize } from "@web/core/utils/functions";
import { renderToElement } from "@web/core/utils/render";
/**
* @typedef { Object } EmbeddedComponentShared
* @property { EmbeddedComponentPlugin['renderBlueprintToElement'] } renderBlueprintToElement
*/
/**
* @typedef {((arg: { name, env, props }) => void)[]} mount_component_handlers
* @typedef {(() => void)[]} post_mount_component_handlers
*/
/**
* This plugin is responsible with providing the API to manipulate/insert
* sub components in an editor.
*/
export class EmbeddedComponentPlugin extends Plugin {
static id = "embeddedComponents";
static dependencies = ["history", "protectedNode", "selection"];
static shared = ["renderBlueprintToElement"];
/** @type {import("plugins").EditorResources} */
resources = {
/** Handlers */
normalize_handlers: withSequence(0, this.normalize.bind(this)),
clean_for_save_handlers: ({ root }) => this.cleanForSave(root),
attribute_change_handlers: this.onChangeAttribute.bind(this),
restore_savepoint_handlers: () => this.handleComponents(this.editable),
history_reset_handlers: () => this.handleComponents(this.editable),
history_reset_from_steps_handlers: () => this.handleComponents(this.editable),
step_added_handlers: ({ stepCommonAncestor }) => this.handleComponents(stepCommonAncestor),
external_step_added_handlers: () => this.handleComponents(this.editable),
serializable_descendants_processors: this.processDescendantsToSerialize.bind(this),
attribute_change_processors: this.onChangeAttribute.bind(this),
savable_mutation_record_predicates: this.isMutationRecordSavable.bind(this),
move_node_whitelist_selectors: "[data-embedded]",
};
setup() {
this.components = new Set();
// map from node to component info
this.nodeMap = new WeakMap();
this.app = this.config.embeddedComponentInfo.app;
this.env = this.config.embeddedComponentInfo.env ?? {};
this.hostToStateChangeManagerMap = new WeakMap();
this.hostToOnComponentInsertedMap = new WeakMap();
this.embeddedComponents = memoize((embeddedComponents = []) => {
const result = {};
for (const embedding of embeddedComponents) {
// TODO ABD: Any embedding with the same name as another will overwrite it.
// File currently relies on this system. Change it ?
result[embedding.name] = embedding;
}
return result;
});
// First mount is done during history_reset_handlers which happens
// when start_edition_handlers are called.
}
isMutationRecordSavable(record) {
const info = this.nodeMap.get(record.target);
if (
info &&
record.type === "attributes" &&
record.attributeName === "data-embedded-props"
) {
// This attribute is determined independently for each user
// through `data-embedded-state` attribute mutations.
return false;
}
return true;
}
/**
* @typedef {import("@html_editor/core/history_plugin").Tree} Tree
*
* @param {Node} elem
* @param {Tree[]} serializableDescendants
* @returns {Tree[]}
*/
processDescendantsToSerialize(elem, serializableDescendants) {
const embedding = this.getEmbedding(elem);
if (!embedding) {
return serializableDescendants;
}
return Object.values(embedding.getEditableDescendants?.(elem) || {}).map(nodeToTree);
}
handleComponents(elem) {
this.destroyRemovedComponents([...this.components]);
this.forEachEmbeddedComponentHost(elem, (host, embedding) => {
const info = this.nodeMap.get(host);
if (!info) {
this.mountComponent(host, embedding);
}
});
}
forEachEmbeddedComponentHost(elem, callback) {
const selector = `[data-embedded]`;
const targets = [...elem.querySelectorAll(selector)];
if (elem.matches(selector)) {
targets.unshift(elem);
}
for (const host of targets) {
const embedding = this.getEmbedding(host);
if (!embedding) {
continue;
}
callback(host, embedding);
}
}
getEmbedding(host) {
return this.embeddedComponents(this.getResource("embedded_components"))[
host.dataset.embedded
];
}
/**
* Apply an embedded state change received from `data-embedded-state`
* attribute. In some cases (undo/redo/revertStepsUntil history operations),
* the attribute has to be set to a new value, computed by the
* stateChangeManager.
*
* @param {Object} attributeChange @see HistoryPlugin
* @param { Object } options
* @param { boolean } options.forNewStep whether the mutation is being used
* to create a new step
* @returns {string} new attribute value to set on the node, which might be
* unchanged
*/
onChangeAttribute(attributeChange, { forNewStep = false } = {}) {
const attributeValue = attributeChange.value;
let newAttributeValue;
if (attributeChange.attributeName === "data-embedded-state") {
const attrState = attributeChange.reverse
? attributeChange.oldValue
: attributeChange.value;
const stateChangeManager = this.getStateChangeManager(attributeChange.target);
if (stateChangeManager) {
// onStateChanged returns undefined if no change is needed for
// the attribute value
newAttributeValue = stateChangeManager.onStateChanged(attrState, {
reverse: attributeChange.reverse,
forNewStep,
});
}
}
return newAttributeValue || attributeValue;
}
getStateChangeManager(host) {
const embedding = this.getEmbedding(host);
if (!("getStateChangeManager" in embedding)) {
return null;
}
if (!this.hostToStateChangeManagerMap.has(host)) {
const config = {
host,
commitStateChanges: () => this.dependencies.history.addStep(),
};
const stateChangeManager = embedding.getStateChangeManager(config);
stateChangeManager.setup();
this.hostToStateChangeManagerMap.set(host, stateChangeManager);
}
return this.hostToStateChangeManagerMap.get(host);
}
mountComponent(
host,
{ Component, getEditableDescendants, getProps, name, getStateChangeManager }
) {
const props = getProps?.(host) || {};
const env = Object.create(this.env);
env.editorShared = {};
if (getStateChangeManager) {
env.getStateChangeManager = this.getStateChangeManager.bind(this);
}
if (getEditableDescendants) {
env.getEditableDescendants = getEditableDescendants;
// Enable the automatic selection restoration feature in @see useEditableDescendants
Object.assign(env.editorShared, {
selection: { ...this.dependencies.selection },
});
}
this.dispatchTo("mount_component_handlers", { name, env, props });
const root = this.app.createRoot(Component, {
props,
env,
});
root.mount(host);
// Patch mount fiber to hook into the exact call stack where root is
// mounted (but before). This will remove host children synchronously
// just before adding the root rendered html.
const fiber = root.node.fiber;
const fiberComplete = fiber.complete;
fiber.complete = () => {
host.replaceChildren();
fiberComplete.call(fiber);
this.dispatchTo("post_mount_component_handlers");
};
const onComponentInserted = this.extractOnComponentInserted(host);
if (onComponentInserted) {
// If a pending operation should be executed after the first mount
// of an inserted blueprint, add it as the last `onMounted` callback
root.node.mounted.push(onComponentInserted);
}
const info = {
root,
host,
};
this.components.add(info);
this.nodeMap.set(host, info);
}
destroyRemovedComponents(infos) {
// Avoid registering mutations if removed hosts are handled in
// the same microtask as when they were removed.
this.dependencies.history.ignoreDOMMutations(() => {
for (const info of infos) {
if (!this.editable.contains(info.host)) {
const host = info.host;
const display = host.style.display;
const parentNode = host.parentNode;
const clone = host.cloneNode(false);
if (parentNode) {
parentNode.replaceChild(clone, host);
}
host.style.display = "none";
this.editable.after(host);
this.destroyComponent(info);
if (parentNode) {
parentNode.replaceChild(host, clone);
} else {
host.remove();
}
host.style.display = display;
if (!host.getAttribute("style")) {
host.removeAttribute("style");
}
}
}
});
}
deepDestroyComponent({ host }) {
const removed = [];
this.forEachEmbeddedComponentHost(host, (containedHost) => {
const info = this.nodeMap.get(containedHost);
if (info) {
if (this.editable.contains(containedHost)) {
this.destroyComponent(info);
} else {
removed.push(info);
}
}
});
this.destroyRemovedComponents(removed);
}
/**
* Should not be called directly as it will not handle recursivity and
* removed components @see deepDestroyComponent
*/
destroyComponent({ root, host }) {
const { getEditableDescendants } = this.getEmbedding(host);
const editableDescendants = getEditableDescendants?.(host) || {};
root.destroy();
this.components.delete(arguments[0]);
this.nodeMap.delete(host);
host.append(...Object.values(editableDescendants));
}
destroy() {
super.destroy();
for (const info of [...this.components]) {
if (this.components.has(info)) {
this.deepDestroyComponent(info);
}
}
}
/**
* @param {String} template blueprint for the embedded Component
* @param {Object} [context] rendering context
* @param {Function} [onComponentInserted] function to be executed when
* it is first mounted after it was inserted in the DOM. It will not
* be executed if the blueprint is removed from the DOM before the
* first mount nor if the component is mounted again afterwards.
* @returns {HTMLElement} host
*/
renderBlueprintToElement(template, context = {}, onComponentInserted = undefined) {
const host = renderToElement(template, context);
if (onComponentInserted) {
this.hostToOnComponentInsertedMap.set(host, onComponentInserted);
}
return host;
}
extractOnComponentInserted(host) {
const onComponentInserted = this.hostToOnComponentInsertedMap.get(host);
this.hostToOnComponentInsertedMap.delete(host);
return onComponentInserted;
}
normalize(elem) {
this.forEachEmbeddedComponentHost(elem, (host, { getEditableDescendants }) => {
this.dependencies.protectedNode.setProtectingNode(host, true);
const editableDescendants = getEditableDescendants?.(host) || {};
for (const editableDescendant of Object.values(editableDescendants)) {
this.dependencies.protectedNode.setProtectingNode(editableDescendant, false);
}
});
}
cleanForSave(clone) {
this.forEachEmbeddedComponentHost(clone, (host, { getEditableDescendants }) => {
// In this case, host is a cloned element, there is no OWL root
// attached to it.
const editableDescendants = getEditableDescendants?.(host) || {};
host.replaceChildren();
for (const editableDescendant of Object.values(editableDescendants)) {
delete editableDescendant.dataset.oeProtected;
host.append(editableDescendant);
}
delete host.dataset.oeProtected;
delete host.dataset.embeddedState;
});
}
}