@lofcz/platejs-core 53.1.6 → 53.2.1

package/dist/static/index.d.ts

@@ -1,2 +1,2 @@
-import { $a as SlateHTMLProps, Ba as getSelectedDomNode, Co as SlateRenderLeaf, Do as SlateRenderElement, Eo as pipeRenderElementStatic, Ga as getPluginDataAttributes, Ha as getSelectedDomBlocks, Ia as stripSlateDataAttributes, Ja as ViewPlugin, Ka as createStaticString, La as stripHtmlClassNames, Oo as pluginRenderElementStatic, Qa as SlateElementProps, Ra as pipeDecorate, So as pluginRenderTextStatic, To as pluginRenderLeafStatic, Ua as getRenderNodeStaticProps, Va as getSelectedDomFragment, Wa as getNodeDataAttributes, Xa as getEditorDOMFromHtmlString, Ya as createStaticEditor, Za as SlateElement, _o as LeafStatic, ao as StyledSlateElementProps, bo as SlateRenderText, co as useNodeAttributes, do as SlateRenderLeafProps, eo as SlateLeaf, fo as SlateRenderNodeProps, go as ElementStatic, ho as serializeHtml, io as SlateTextProps, lo as BoxStaticProps, mo as SerializeHtmlOptions, no as SlateNodeProps, oo as StyledSlateLeafProps, po as SlateRenderTextProps, qa as getStaticPlugins, ro as SlateText, so as StyledSlateTextProps, to as SlateLeafProps, uo as SlateRenderElementProps, vo as PlateStatic, wo as pipeRenderLeafStatic, xo as pipeRenderTextStatic, yo as PlateStaticProps, za as isSelectOutside } from "../index-BooMghRU";
+import { $a as getEditorDOMFromHtmlString, Ao as SlateRenderElement, Ba as stripHtmlClassNames, Co as SlateRenderText, Do as pipeRenderLeafStatic, Eo as SlateRenderLeaf, Ga as getSelectedDomBlocks, Ha as isSelectOutside, Ja as getPluginDataAttributes, Ka as getRenderNodeStaticProps, Oo as pluginRenderLeafStatic, Qa as createStaticEditor, So as PlateStaticProps, To as pluginRenderTextStatic, Ua as getSelectedDomNode, Va as pipeDecorate, Wa as getSelectedDomFragment, Xa as getStaticPlugins, Ya as createStaticString, Za as ViewPlugin, _o as SerializeHtmlOptions, ao as SlateNodeProps, bo as LeafStatic, co as StyledSlateElementProps, do as useNodeAttributes, eo as SlateElement, fo as BoxStaticProps, go as SlateRenderTextProps, ho as SlateRenderNodeProps, io as SlateLeafProps, jo as pluginRenderElementStatic, ko as pipeRenderElementStatic, lo as StyledSlateLeafProps, mo as SlateRenderLeafProps, no as SlateHTMLProps, oo as SlateText, po as SlateRenderElementProps, qa as getNodeDataAttributes, ro as SlateLeaf, so as SlateTextProps, to as SlateElementProps, uo as StyledSlateTextProps, vo as serializeHtml, wo as pipeRenderTextStatic, xo as PlateStatic, yo as ElementStatic, za as stripSlateDataAttributes } from "../index-ClAE30YQ";
 export { BoxStaticProps, ElementStatic, LeafStatic, PlateStatic, PlateStaticProps, SerializeHtmlOptions, SlateElement, SlateElementProps, SlateHTMLProps, SlateLeaf, SlateLeafProps, SlateNodeProps, SlateRenderElement, SlateRenderElementProps, SlateRenderLeaf, SlateRenderLeafProps, SlateRenderNodeProps, SlateRenderText, SlateRenderTextProps, SlateText, SlateTextProps, StyledSlateElementProps, StyledSlateLeafProps, StyledSlateTextProps, ViewPlugin, createStaticEditor, createStaticString, getEditorDOMFromHtmlString, getNodeDataAttributes, getPluginDataAttributes, getRenderNodeStaticProps, getSelectedDomBlocks, getSelectedDomFragment, getSelectedDomNode, getStaticPlugins, isSelectOutside, pipeDecorate, pipeRenderElementStatic, pipeRenderLeafStatic, pipeRenderTextStatic, pluginRenderElementStatic, pluginRenderLeafStatic, pluginRenderTextStatic, serializeHtml, stripHtmlClassNames, stripSlateDataAttributes, useNodeAttributes };

package/dist/static/index.js

@@ -1,4 +1,4 @@
-import "../withSlate-Ck8dLhUt.js";
-import { C as createStaticEditor, D as getSelectedDomNode, E as isSelectOutside, O as getSelectedDomFragment, S as useNodeAttributes, T as ViewPlugin, _ as getPluginDataAttributes, a as ElementStatic, b as SlateLeaf, c as pipeRenderTextStatic, d as pluginRenderElementStatic, f as stripSlateDataAttributes, g as getNodeDataAttributes, h as getRenderNodeStaticProps, i as pluginRenderLeafStatic, k as pipeDecorate, l as pluginRenderTextStatic, m as getSelectedDomBlocks, n as serializeHtml, o as LeafStatic, p as stripHtmlClassNames, r as pipeRenderLeafStatic, s as PlateStatic, t as getEditorDOMFromHtmlString, u as pipeRenderElementStatic, v as createStaticString, w as getStaticPlugins, x as SlateText, y as SlateElement } from "../static-DAs0P1Ms.js";
+import "../withSlate-pfxNb3FA.js";
+import { C as createStaticEditor, D as getSelectedDomNode, E as isSelectOutside, O as getSelectedDomFragment, S as useNodeAttributes, T as ViewPlugin, _ as getPluginDataAttributes, a as ElementStatic, b as SlateLeaf, c as pipeRenderTextStatic, d as pluginRenderElementStatic, f as stripSlateDataAttributes, g as getNodeDataAttributes, h as getRenderNodeStaticProps, i as pluginRenderLeafStatic, k as pipeDecorate, l as pluginRenderTextStatic, m as getSelectedDomBlocks, n as serializeHtml, o as LeafStatic, p as stripHtmlClassNames, r as pipeRenderLeafStatic, s as PlateStatic, t as getEditorDOMFromHtmlString, u as pipeRenderElementStatic, v as createStaticString, w as getStaticPlugins, x as SlateText, y as SlateElement } from "../static-C-jR24Fx.js";
 
 export { ElementStatic, LeafStatic, PlateStatic, SlateElement, SlateLeaf, SlateText, ViewPlugin, createStaticEditor, createStaticString, getEditorDOMFromHtmlString, getNodeDataAttributes, getPluginDataAttributes, getRenderNodeStaticProps, getSelectedDomBlocks, getSelectedDomFragment, getSelectedDomNode, getStaticPlugins, isSelectOutside, pipeDecorate, pipeRenderElementStatic, pipeRenderLeafStatic, pipeRenderTextStatic, pluginRenderElementStatic, pluginRenderLeafStatic, pluginRenderTextStatic, serializeHtml, stripHtmlClassNames, stripSlateDataAttributes, useNodeAttributes };

package/dist/{static-DAs0P1Ms.js → static-C-jR24Fx.js}

@@ -1,4 +1,4 @@
-import { Ct as getInjectMatch, at as DOMPlugin, n as withSlate, p as isEditOnly, sn as getEditorPlugin, tn as getPluginByType, vt as getSlateClass, xt as keyToDataAttribute, yt as getPluginNodeProps } from "./withSlate-Ck8dLhUt.js";
+import { Ct as keyToDataAttribute, Tt as getInjectMatch, bt as getSlateClass, cn as getEditorPlugin, m as isEditOnly, n as withSlate, nn as getPluginByType, st as DOMPlugin, xt as getPluginNodeProps } from "./withSlate-pfxNb3FA.js";
 import { ElementApi, NodeApi, RangeApi, TextApi, createEditor, isElementDecorationsEqual, isTextDecorationsEqual } from "@platejs/slate";
 import { isDefined } from "@udecode/utils";
 import React from "react";
@@ -14,13 +14,13 @@ import { decode } from "html-entities";
 * `[styleKey]: value`.
 */
 const pluginInjectNodeProps = (editor, plugin, nodeProps, getElementPath) => {
-	const { key, inject: { nodeProps: injectNodeProps } } = plugin;
+	const { key, inject: { excludeBelowPlugins, maxLevel, nodeProps: injectNodeProps } } = plugin;
 	const { element, text } = nodeProps;
 	const node = element ?? text;
 	if (!node) return;
 	if (!injectNodeProps) return;
 	const { classNames, defaultNodeValue, nodeKey = editor.getType(key), query, styleKey = nodeKey, transformClassName, transformNodeValue, transformProps, transformStyle, validNodeValues } = injectNodeProps;
-	if (!getInjectMatch(editor, plugin)(node, !!(plugin.inject.excludeBelowPlugins || plugin.inject.maxLevel) ? getElementPath(node) : void 0)) return;
+	if (!getInjectMatch(editor, plugin)(node, !!(excludeBelowPlugins || maxLevel) ? getElementPath(node) : void 0)) return;
 	const queryResult = query?.({
 		...injectNodeProps,
 		...getEditorPlugin(editor, plugin),

package/dist/{withSlate-Ck8dLhUt.js → withSlate-pfxNb3FA.js}

@@ -4,7 +4,6 @@ import { bindFirst, isDefined } from "@udecode/utils";
 import merge from "lodash/merge.js";
 import { createVanillaStore } from "zustand-x/vanilla";
 import mergeWith from "lodash/mergeWith.js";
-import defaults from "lodash/defaults.js";
 import kebabCase from "lodash/kebabCase.js";
 import pick from "lodash/pick.js";
 import castArray from "lodash/castArray.js";
@@ -783,12 +782,13 @@ const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore)
 		node: {
 			isContainer: [],
 			isLeaf: [],
+			isMetadataProp: [],
 			isText: [],
 			leafProps: [],
 			textProps: [],
 			types: {}
 		},
-		normalizeInitialValue: [],
+		transformInitialValue: [],
 		render: {
 			aboveEditable: [],
 			aboveNodes: [],
@@ -814,6 +814,7 @@ const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore)
 		}
 		resolvePluginMethods(editor, plugin);
 		if (plugin.node?.isContainer) editor.meta.pluginCache.node.isContainer.push(plugin.key);
+		if (plugin.node?.isMetadataProp) editor.meta.pluginCache.node.isMetadataProp.push(plugin.key);
 		editor.meta.pluginCache.node.types[plugin.node.type] = plugin.key;
 		if (plugin.inject?.nodeProps) editor.meta.pluginCache.inject.nodeProps.push(plugin.key);
 		if (plugin.render?.node) editor.meta.components[plugin.key] = plugin.render.node;
@@ -829,7 +830,7 @@ const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore)
 		if (plugin.render.afterContainer) editor.meta.pluginCache.render.afterContainer.push(plugin.key);
 		if (plugin.render.beforeContainer) editor.meta.pluginCache.render.beforeContainer.push(plugin.key);
 		if (plugin.render.belowRootNodes) editor.meta.pluginCache.render.belowRootNodes.push(plugin.key);
-		if (plugin.normalizeInitialValue) editor.meta.pluginCache.normalizeInitialValue.push(plugin.key);
+		if (plugin.transformInitialValue || plugin.normalizeInitialValue) editor.meta.pluginCache.transformInitialValue.push(plugin.key);
 		if (plugin.decorate) editor.meta.pluginCache.decorate.push(plugin.key);
 		if (plugin.render.aboveNodes) editor.meta.pluginCache.render.aboveNodes.push(plugin.key);
 		if (plugin.render.belowNodes) editor.meta.pluginCache.render.belowNodes.push(plugin.key);
@@ -1456,16 +1457,6 @@ const isSlatePluginElement = (element, pluginKey) => element.dataset.slateNode =
 const isSlatePluginNode = (element, pluginKey) => element.classList.contains(`slate-${pluginKey}`);
 const getSlateElements = (element) => Array.from(element.querySelectorAll("[data-slate-node=\"element\"]"));
 
-//#endregion
-//#region src/lib/utils/defaultsDeepToNodes.ts
-/** Recursively merge a source object to children nodes with a query. */
-const defaultsDeepToNodes = (options) => {
-	applyDeepToNodes({
-		...options,
-		apply: defaults
-	});
-};
-
 //#endregion
 //#region src/lib/utils/getInjectMatch.ts
 const getInjectMatch = (editor, plugin) => {
@@ -2732,6 +2723,7 @@ const NavigationFeedbackPlugin = createTSlatePlugin({
 
 //#endregion
 //#region src/lib/plugins/node-id/withNodeId.ts
+const now = () => globalThis.performance?.now() ?? Date.now();
 /** Enables support for inserting nodes with an id key. */
 const withNodeId = ({ editor, getOptions, tf: { apply, insertNode, insertNodes } }) => {
 	const idPropsCreator = () => ({ [getOptions().idKey ?? ""]: getOptions().idCreator() });
@@ -2739,23 +2731,42 @@ const withNodeId = ({ editor, getOptions, tf: { apply, insertNode, insertNodes }
 		const { filter, filterText } = getOptions();
 		return filter(nodeEntry) && (!filterText || nodeEntry[0]?.type !== void 0);
 	};
-	const removeIdFromNodeIfDuplicate = (node) => {
-		const { idKey = "", reuseId } = getOptions();
-		if (!reuseId && editor.api.some({
-			at: [],
-			match: { [idKey]: node[idKey] }
-		})) delete node[idKey];
+	const collectDuplicateCandidateIds = ({ disableInsertOverrides, idKey, nodeEntry, query }) => {
+		const duplicateCandidateIds = /* @__PURE__ */ new Set();
+		const collectNodeIds = (entry) => {
+			const [entryNode, path] = entry;
+			if (queryNode(entry, query)) {
+				if (entryNode[idKey] !== void 0) duplicateCandidateIds.add(entryNode[idKey]);
+				if (!disableInsertOverrides && isDefined(entryNode._id)) duplicateCandidateIds.add(entryNode._id);
+			}
+			const children = entryNode.children;
+			if (!children) return;
+			children.forEach((child, index) => {
+				collectNodeIds([child, [...path, index]]);
+			});
+		};
+		collectNodeIds(nodeEntry);
+		return duplicateCandidateIds;
 	};
-	const overrideIdIfSet = (node) => {
-		const { idKey = "" } = getOptions();
-		if (isDefined(node._id)) {
-			const id = node._id;
-			node._id = void 0;
-			if (!editor.api.some({
-				at: [],
-				match: { [idKey]: id }
-			})) node[idKey] = id;
+	const collectExistingEditorIds = ({ duplicateCandidateIds, idKey }) => {
+		if (duplicateCandidateIds.size === 0) return /* @__PURE__ */ new Set();
+		const existingIds = /* @__PURE__ */ new Set();
+		const start = now();
+		let visitedCount = 0;
+		for (const [entryNode] of NodeApi.nodes(editor)) {
+			visitedCount += 1;
+			const id = entryNode?.[idKey];
+			if (id === void 0 || !duplicateCandidateIds.has(id)) continue;
+			existingIds.add(id);
+			if (existingIds.size === duplicateCandidateIds.size) break;
 		}
+		getOptions().onDuplicateIdScan?.({
+			candidateCount: duplicateCandidateIds.size,
+			duration: now() - start,
+			existingCount: existingIds.size,
+			visitedCount
+		});
+		return existingIds;
 	};
 	return { transforms: {
 		apply(operation) {
@@ -2767,24 +2778,34 @@ const withNodeId = ({ editor, getOptions, tf: { apply, insertNode, insertNodes }
 			};
 			if (operation.type === "insert_node") {
 				const node = cloneDeep(operation.node);
-				applyDeepToNodes({
-					apply: removeIdFromNodeIfDuplicate,
-					node,
-					query,
-					source: {}
-				});
-				defaultsDeepToNodes({
-					node,
-					path: operation.path,
-					query,
-					source: idPropsCreator
-				});
-				if (!disableInsertOverrides) applyDeepToNodes({
-					apply: overrideIdIfSet,
-					node,
-					query,
-					source: {}
+				const existingIds = collectExistingEditorIds({
+					duplicateCandidateIds: collectDuplicateCandidateIds({
+						disableInsertOverrides,
+						idKey,
+						nodeEntry: [node, operation.path],
+						query
+					}),
+					idKey
 				});
+				const hasIdInEditor = (id) => existingIds.has(id);
+				const normalizeInsertedNode = (nodeEntry) => {
+					const [entryNode, path] = nodeEntry;
+					if (queryNode(nodeEntry, query)) {
+						if (entryNode[idKey] !== void 0 && hasIdInEditor(entryNode[idKey])) delete entryNode[idKey];
+						if (entryNode[idKey] === void 0) Object.assign(entryNode, idPropsCreator());
+						if (!disableInsertOverrides && isDefined(entryNode._id)) {
+							const id = entryNode._id;
+							entryNode._id = void 0;
+							if (!hasIdInEditor(id)) entryNode[idKey] = id;
+						}
+					}
+					const children = entryNode.children;
+					if (!children) return;
+					children.forEach((child, index) => {
+						normalizeInsertedNode([child, [...path, index]]);
+					});
+				};
+				normalizeInsertedNode([node, operation.path]);
 				return apply({
 					...operation,
 					node
@@ -2841,29 +2862,103 @@ const withNodeId = ({ editor, getOptions, tf: { apply, insertNode, insertNodes }
 
 //#endregion
 //#region src/lib/plugins/node-id/NodeIdPlugin.ts
+const defaultNodeIdFilter = () => true;
+const isDefaultNodeIdFastPath = ({ allow, exclude, filter, filterInline = true, filterText = true }) => allow === void 0 && exclude === void 0 && (filter === void 0 || filter === defaultNodeIdFilter) && filterInline && filterText;
+const isBlockCandidate = (node, isBlock) => ElementApi.isElement(node) && (isBlock ? isBlock(node) : node.inline !== true);
+const shouldAssignNodeId = (entry, options = {}) => {
+	const { allow, exclude, filter = () => true, filterInline = true, filterText = true, isBlock, idKey = "id" } = options;
+	const [node, path] = entry;
+	return !node[idKey] && queryNode([node, path], {
+		allow,
+		exclude,
+		filter: (nextEntry) => {
+			const [entryNode] = nextEntry;
+			if (filterText && !ElementApi.isElement(entryNode)) return false;
+			if (filterInline && ElementApi.isElement(entryNode) && !(isBlock ? isBlock(entryNode) : entryNode.inline !== true)) return false;
+			return filter(nextEntry);
+		}
+	});
+};
+const resolveInitialValueIds = (options) => {
+	if (options.initialValueIds !== void 0) return options.initialValueIds;
+	if (options.normalizeInitialValue === null) return false;
+	if (options.normalizeInitialValue === true) return "always";
+	return "if-needed";
+};
 /**
 * Normalize node IDs in a value without using editor operations. This is a pure
-* function that returns a new normalized value.
+* function that returns the normalized value and preserves references for
+* unchanged branches.
 */
-const normalizeNodeId = (value, options = {}) => {
-	const { allow, exclude, filter = () => true, filterInline = true, filterText = true, idCreator = () => nanoid(10), idKey = "id" } = options;
+const normalizeNodeIdRuntime = (value, options = {}) => {
+	const { idCreator = () => nanoid(10), idKey = "id" } = options;
+	if (isDefaultNodeIdFastPath(options)) {
+		const normalizeNodeFast = (node) => {
+			if (!ElementApi.isElement(node)) return node;
+			if (!isBlockCandidate(node, options.isBlock)) return node;
+			let nextChildren;
+			node.children.forEach((child, index) => {
+				const nextChild = normalizeNodeFast(child);
+				if (nextChild !== child) {
+					if (!nextChildren) nextChildren = [...node.children];
+					nextChildren[index] = nextChild;
+				}
+			});
+			if (!node[idKey]) return {
+				...node,
+				...nextChildren ? { children: nextChildren } : {},
+				[idKey]: idCreator()
+			};
+			if (nextChildren) return {
+				...node,
+				children: nextChildren
+			};
+			return node;
+		};
+		let valueChanged$1 = false;
+		const nextValue$1 = value.map((node) => {
+			const nextNode = normalizeNodeFast(node);
+			if (nextNode !== node) valueChanged$1 = true;
+			return nextNode;
+		});
+		return valueChanged$1 ? nextValue$1 : value;
+	}
 	const normalizeNode = (node, path) => {
-		const clonedNode = { ...node };
-		if (!clonedNode[idKey] && queryNode([clonedNode, path], {
-			allow,
-			exclude,
-			filter: (entry) => {
-				const [node$1] = entry;
-				if (filterText && !ElementApi.isElement(node$1)) return false;
-				if (filterInline && ElementApi.isElement(node$1) && node$1.inline === true) return false;
-				return filter(entry);
-			}
-		})) clonedNode[idKey] = idCreator();
-		if (ElementApi.isElement(clonedNode)) clonedNode.children = clonedNode.children.map((child, index) => normalizeNode(child, [...path, index]));
-		return clonedNode;
+		let nextNode = node;
+		let childrenChanged = false;
+		if (shouldAssignNodeId([node, path], options)) nextNode = {
+			...node,
+			[idKey]: idCreator()
+		};
+		if (ElementApi.isElement(node)) {
+			const nextChildren = node.children.map((child, index) => {
+				const nextChild = normalizeNode(child, [...path, index]);
+				if (nextChild !== child) childrenChanged = true;
+				return nextChild;
+			});
+			if (childrenChanged) nextNode = nextNode === node ? {
+				...node,
+				children: nextChildren
+			} : {
+				...nextNode,
+				children: nextChildren
+			};
+		}
+		return nextNode;
 	};
-	return value.map((node, index) => normalizeNode(node, [index]));
+	let valueChanged = false;
+	const nextValue = value.map((node, index) => {
+		const nextNode = normalizeNode(node, [index]);
+		if (nextNode !== node) valueChanged = true;
+		return nextNode;
+	});
+	return valueChanged ? nextValue : value;
 };
+const normalizeNodeId = (value, options = {}) => normalizeNodeIdRuntime(value, options);
+const normalizeNodeIdWithEditor = (editor, value, options = {}) => normalizeNodeIdRuntime(value, {
+	...options,
+	isBlock: editor.api.isBlock
+});
 /** @see {@link withNodeId} */
 const NodeIdPlugin = createTSlatePlugin({
 	key: "nodeId",
@@ -2871,29 +2966,51 @@ const NodeIdPlugin = createTSlatePlugin({
 		filterInline: true,
 		filterText: true,
 		idKey: "id",
-		normalizeInitialValue: false,
-		filter: () => true,
+		filter: defaultNodeIdFilter,
 		idCreator: () => nanoid(10)
 	}
-}).extendTransforms(({ editor, getOptions }) => ({ normalize() {
-	const { allow, exclude, filter, filterInline, filterText, idKey } = getOptions();
+}).extend(({ getOptions }) => ({ node: { isMetadataProp: ({ key }) => key === (getOptions().idKey ?? "id") } })).extendTransforms(({ editor, getOptions }) => ({ normalize() {
+	const options = getOptions();
+	const { idCreator, idKey } = options;
+	const updates = [];
+	if (isDefaultNodeIdFastPath({
+		...options,
+		isBlock: editor.api.isBlock
+	})) {
+		const path = [];
+		const visitFast = (node) => {
+			if (!ElementApi.isElement(node)) return;
+			if (!isBlockCandidate(node, editor.api.isBlock)) return;
+			if (!node[idKey]) updates.push({
+				at: [...path],
+				props: { [idKey]: idCreator() }
+			});
+			node.children.forEach((child, index) => {
+				path.push(index);
+				visitFast(child);
+				path.pop();
+			});
+		};
+		editor.children.forEach((node, index) => {
+			path.push(index);
+			visitFast(node);
+			path.pop();
+		});
+		if (updates.length === 0) return;
+		editor.tf.withoutSaving(() => {
+			editor.tf.setNodesBatch(updates);
+		});
+		return;
+	}
 	const addNodeId = (entry) => {
 		const [node, path] = entry;
-		if (!node[idKey] && queryNode([node, path], {
-			allow,
-			exclude,
-			filter: (entry$1) => {
-				const [node$1] = entry$1;
-				if (filterText && !ElementApi.isElement(node$1)) return false;
-				if (filterInline && ElementApi.isElement(node$1) && !editor.api.isBlock(node$1)) return false;
-				return filter(entry$1);
-			}
-		})) {
-			if (!editor.api.node(path)) return;
-			editor.tf.withoutSaving(() => {
-				editor.tf.setNodes({ [idKey]: getOptions().idCreator() }, { at: path });
-			});
-		}
+		if (shouldAssignNodeId(entry, {
+			...options,
+			isBlock: editor.api.isBlock
+		})) updates.push({
+			at: path,
+			props: { [idKey]: idCreator() }
+		});
 		if (ElementApi.isElement(node)) node.children.forEach((child, index) => {
 			addNodeId([child, [...path, index]]);
 		});
@@ -2901,14 +3018,21 @@ const NodeIdPlugin = createTSlatePlugin({
 	editor.children.forEach((node, index) => {
 		addNodeId([node, [index]]);
 	});
-} })).extend({ normalizeInitialValue: ({ editor, getOptions, tf }) => {
-	const { normalizeInitialValue } = getOptions();
-	if (!normalizeInitialValue) {
-		const firstNode = editor.children[0];
-		const lastNode = editor.children.at(-1);
-		if (firstNode?.id && lastNode?.id) return;
+	if (updates.length === 0) return;
+	editor.tf.withoutSaving(() => {
+		editor.tf.setNodesBatch(updates);
+	});
+} })).extend({ transformInitialValue: ({ editor, getOptions, value }) => {
+	const options = getOptions();
+	const { idKey = "id" } = options;
+	const initialValueIds = resolveInitialValueIds(options);
+	if (initialValueIds === false) return value;
+	if (initialValueIds === "if-needed") {
+		const firstNode = value[0];
+		const lastNode = value.at(-1);
+		if (firstNode?.[idKey] && lastNode?.[idKey]) return value;
 	}
-	tf.nodeId.normalize();
+	return normalizeNodeIdWithEditor(editor, value, options);
 } }).overrideEditor(withNodeId);
 
 //#endregion
@@ -2957,7 +3081,7 @@ const pipeOnTextChange = (editor, node, text, prevText, operation) => {
 const DEFAULT = {
 	handlers: true,
 	inject: true,
-	normalizeInitialValue: false,
+	transformInitialValue: false,
 	render: true
 };
 /**
@@ -2967,29 +3091,43 @@ const DEFAULT = {
 * @param plugin The plugin to check
 * @param isReadOnly Whether the editor is in read-only mode
 * @param feature The feature to check ('render' | 'handlers' | 'inject' |
-*   'normalizeInitialValue')
+*   'transformInitialValue')
 * @returns True if the feature should be disabled
 */
 const isEditOnly = (readOnly, plugin, feature) => {
 	if (!readOnly) return false;
-	if (plugin.editOnly === true) return DEFAULT[feature];
-	if (typeof plugin.editOnly === "object") return plugin.editOnly[feature] ?? DEFAULT[feature];
+	const resolvedFeature = feature === "normalizeInitialValue" ? "transformInitialValue" : feature;
+	if (plugin.editOnly === true) return DEFAULT[resolvedFeature];
+	if (typeof plugin.editOnly === "object") {
+		if (plugin.editOnly[resolvedFeature] !== void 0) return plugin.editOnly[resolvedFeature];
+		if (resolvedFeature === "transformInitialValue") return plugin.editOnly.normalizeInitialValue ?? DEFAULT.transformInitialValue;
+		return DEFAULT[resolvedFeature];
+	}
 	return false;
 };
 
 //#endregion
-//#region src/internal/plugin/pipeNormalizeInitialValue.ts
-/** Normalize initial value from editor plugins. Set into plate store if diff. */
-const pipeNormalizeInitialValue = (editor) => {
+//#region src/internal/plugin/pipeTransformInitialValue.ts
+/** Transform initial value from editor plugins before the editor is ready. */
+const pipeTransformInitialValue = (editor) => {
 	const value = editor.meta.isNormalizing;
 	editor.meta.isNormalizing = true;
-	editor.meta.pluginCache.normalizeInitialValue.forEach((key) => {
+	editor.meta.pluginCache.transformInitialValue.forEach((key) => {
 		const p = editor.getPlugin({ key });
-		if (isEditOnly(editor.dom.readOnly, p, "normalizeInitialValue")) return;
-		p.normalizeInitialValue?.({
+		if (isEditOnly(editor.dom.readOnly, p, "transformInitialValue")) return;
+		if (!p.transformInitialValue && !p.normalizeInitialValue) return;
+		const ctx = {
 			...getEditorPlugin(editor, p),
 			value: editor.children
-		});
+		};
+		if (p.transformInitialValue) {
+			const nextValue$1 = p.transformInitialValue(ctx);
+			if (nextValue$1 === void 0) throw new Error(`Plugin "${key}" transformInitialValue must return the next value.`);
+			editor.children = nextValue$1;
+			return;
+		}
+		const nextValue = p.normalizeInitialValue?.(ctx);
+		if (nextValue !== void 0) editor.children = nextValue;
 	});
 	editor.meta.isNormalizing = value;
 };
@@ -3004,7 +3142,7 @@ const init = (editor, { autoSelect, selection, shouldNormalizeEditor, value, onR
 			const target = (autoSelect === "start" ? "start" : "end") === "start" ? editor.api.start([]) : editor.api.end([]);
 			editor.tf.select(target);
 		}
-		if (editor.children.length > 0) pipeNormalizeInitialValue(editor);
+		if (editor.children.length > 0) pipeTransformInitialValue(editor);
 		if (shouldNormalizeEditor) editor.tf.normalize({ force: true });
 		if (onReady) onReady({
 			editor,
@@ -3129,6 +3267,21 @@ const setValue = (editor, value) => {
 //#region src/lib/plugins/slate-extension/SlateExtensionPlugin.ts
 const NOOP_ON_NODE_CHANGE = () => {};
 const NOOP_ON_TEXT_CHANGE = () => {};
+const isElementStateEmpty = (editor, element) => {
+	const props = NodeApi.extractProps(element);
+	return Object.entries(props).every(([key, value]) => {
+		if (key === "type") return true;
+		return editor.meta.pluginCache.node.isMetadataProp.some((pluginKey) => {
+			const plugin = editor.plugins[pluginKey];
+			return plugin.node.isMetadataProp?.({
+				...getEditorPlugin(editor, plugin),
+				key,
+				node: element,
+				value
+			});
+		});
+	});
+};
 /** Opinionated extension of slate default behavior. */
 const SlateExtensionPlugin = createTSlatePlugin({
 	api: { redecorate: () => {} },
@@ -3137,7 +3290,7 @@ const SlateExtensionPlugin = createTSlatePlugin({
 		onNodeChange: NOOP_ON_NODE_CHANGE,
 		onTextChange: NOOP_ON_TEXT_CHANGE
 	}
-}).extendEditorTransforms(({ editor, getOption, tf }) => {
+}).extendEditorApi(({ editor }) => ({ isElementStateEmpty: bindFirst(isElementStateEmpty, editor) })).extendEditorTransforms(({ editor, getOption, tf }) => {
 	const apply = tf?.apply ?? editor.tf.apply;
 	return {
 		init: bindFirst(init, editor),
@@ -3671,4 +3824,4 @@ const withSlate = (e, { id, affinity = true, autoSelect, chunking = true, maxLen
 const createSlateEditor = ({ editor = createEditor(), ...options } = {}) => withSlate(editor, options);
 
 //#endregion
-export { isHtmlBlockElement as $, defineInputRule as $t, htmlStringToDOMNode as A, isSlatePluginElement as At, htmlBrToNewLine as B, withDeleteRules as Bt, resolveNavigationFeedbackTarget as C, getInjectMatch as Ct, HtmlPlugin as D, isSlateElement as Dt, LengthPlugin as E, isSlateEditor as Et, pipeDeserializeHtmlLeaf as F, applyDeepToNodes as Ft, inferWhiteSpaceRule as G, AstPlugin as Gt, deserializeHtmlNodeChildren as H, BaseParagraphPlugin as Ht, htmlElementToElement as I, OverridePlugin as It, collapseWhiteSpaceText as J, createMarkInputRule as Jt, collapseWhiteSpaceChildren as K, createBlockFenceInputRule as Kt, pipeDeserializeHtmlElement as L, withOverrides as Lt, deserializeHtmlNode as M, isSlateString as Mt, htmlTextNodeToString as N, isSlateText as Nt, parseHtmlDocument as O, isSlateLeaf as Ot, htmlElementToLeaf as P, isSlateVoid as Pt, collapseString as Q, matchDelimitedInline as Qt, pluginDeserializeHtml as R, withNormalizeRules as Rt, flashTarget as S, getInjectedPlugins as St, NavigationFeedbackPluginKey as T, getSlateElements as Tt, collapseWhiteSpace as U, HistoryPlugin as Ut, htmlBodyToFragment as V, withBreakRules as Vt, collapseWhiteSpaceElement as W, withPlateHistory as Wt, upsertInlineFormattingContext as X, matchBlockFence as Xt, endInlineFormattingContext as Y, createTextSubstitutionInputRule as Yt, isLastNonEmptyTextOfInlineFormattingContext as Z, matchBlockStart as Zt, normalizeNodeId as _, mergeDeepToNodes as _t, pipeInsertDataQuery as a, getPluginTypes as an, DOMPlugin as at, navigate as b, getNodeDataAttributeKeys as bt, setValue as c, createSlatePlugin as cn, PlateError as ct, insertExitBreak as d, AffinityPlugin as dt, getContainerTypes as en, isHtmlInlineElement as et, init as f, setAffinitySelection as ft, NodeIdPlugin as g, getEdgeNodes as gt, pipeOnNodeChange as h, getMarkBoundaryAffinity as ht, ParserPlugin as i, getPluginType as in, AUTO_SCROLL as it, deserializeHtmlElement as j, isSlatePluginNode as jt, deserializeHtml as k, isSlateNode as kt, resetBlock as l, createTSlatePlugin as ln, ChunkingPlugin as lt, pipeOnTextChange as m, isNodesAffinity as mt, withSlate as n, getPluginKey as nn, isHtmlText as nt, normalizeDescendantsToDocumentFragment as o, getSlatePlugin as on, withScrolling as ot, isEditOnly as p, isNodeAffinity as pt, collapseWhiteSpaceNode as q, createBlockStartInputRule as qt, getCorePlugins as r, getPluginKeys as rn, isHtmlElement as rt, SlateExtensionPlugin as s, getEditorPlugin as sn, DebugPlugin as st, createSlateEditor as t, getPluginByType as tn, inlineTagNames as tt, liftBlock as u, withChunking as ut, withNodeId as v, getSlateClass as vt, NAVIGATION_FEEDBACK_KEY as w, defaultsDeepToNodes as wt, clearNavigationFeedbackTarget as x, keyToDataAttribute as xt, NavigationFeedbackPlugin as y, getPluginNodeProps as yt, getDataNodeProps as z, withMergeRules as zt };
+export { isLastNonEmptyTextOfInlineFormattingContext as $, matchDelimitedInline as $t, parseHtmlDocument as A, isSlateNode as At, pluginDeserializeHtml as B, withMergeRules as Bt, clearNavigationFeedbackTarget as C, keyToDataAttribute as Ct, NavigationFeedbackPluginKey as D, isSlateEditor as Dt, NAVIGATION_FEEDBACK_KEY as E, getSlateElements as Et, htmlTextNodeToString as F, isSlateVoid as Ft, collapseWhiteSpace as G, withPlateHistory as Gt, htmlBrToNewLine as H, withBreakRules as Ht, htmlElementToLeaf as I, applyDeepToNodes as It, collapseWhiteSpaceChildren as J, createBlockStartInputRule as Jt, collapseWhiteSpaceElement as K, AstPlugin as Kt, pipeDeserializeHtmlLeaf as L, OverridePlugin as Lt, htmlStringToDOMNode as M, isSlatePluginNode as Mt, deserializeHtmlElement as N, isSlateString as Nt, LengthPlugin as O, isSlateElement as Ot, deserializeHtmlNode as P, isSlateText as Pt, upsertInlineFormattingContext as Q, matchBlockStart as Qt, htmlElementToElement as R, withOverrides as Rt, navigate as S, getNodeDataAttributeKeys as St, resolveNavigationFeedbackTarget as T, getInjectMatch as Tt, htmlBodyToFragment as U, BaseParagraphPlugin as Ut, getDataNodeProps as V, withDeleteRules as Vt, deserializeHtmlNodeChildren as W, HistoryPlugin as Wt, collapseWhiteSpaceText as X, createTextSubstitutionInputRule as Xt, collapseWhiteSpaceNode as Y, createMarkInputRule as Yt, endInlineFormattingContext as Z, matchBlockFence as Zt, NodeIdPlugin as _, getMarkBoundaryAffinity as _t, pipeInsertDataQuery as a, getPluginType as an, isHtmlElement as at, withNodeId as b, getSlateClass as bt, isElementStateEmpty as c, getEditorPlugin as cn, withScrolling as ct, liftBlock as d, ChunkingPlugin as dt, defineInputRule as en, collapseString as et, insertExitBreak as f, withChunking as ft, pipeOnNodeChange as g, isNodesAffinity as gt, pipeOnTextChange as h, isNodeAffinity as ht, ParserPlugin as i, getPluginKeys as in, isHtmlText as it, deserializeHtml as j, isSlatePluginElement as jt, HtmlPlugin as k, isSlateLeaf as kt, setValue as l, createSlatePlugin as ln, DebugPlugin as lt, isEditOnly as m, setAffinitySelection as mt, withSlate as n, getPluginByType as nn, isHtmlInlineElement as nt, normalizeDescendantsToDocumentFragment as o, getPluginTypes as on, AUTO_SCROLL as ot, init as p, AffinityPlugin as pt, inferWhiteSpaceRule as q, createBlockFenceInputRule as qt, getCorePlugins as r, getPluginKey as rn, inlineTagNames as rt, SlateExtensionPlugin as s, getSlatePlugin as sn, DOMPlugin as st, createSlateEditor as t, getContainerTypes as tn, isHtmlBlockElement as tt, resetBlock as u, createTSlatePlugin as un, PlateError as ut, normalizeNodeId as v, getEdgeNodes as vt, flashTarget as w, getInjectedPlugins as wt, NavigationFeedbackPlugin as x, getPluginNodeProps as xt, normalizeNodeIdWithEditor as y, mergeDeepToNodes as yt, pipeDeserializeHtmlElement as z, withNormalizeRules as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-core",
-  "version": "53.1.6",
+  "version": "53.2.1",
   "description": "The core of Plate – a plugin system for slate",
   "keywords": [
     "contentEditable",
@@ -41,19 +41,19 @@
     "is-hotkey": "^0.2.0",
     "jotai": "~2.8.4",
     "jotai-optics": "0.4.0",
-    "jotai-x": "2.3.3",
+    "jotai-x": "2.3.4",
     "lodash": "^4.17.21",
     "nanoid": "^5.1.5",
     "optics-ts": "2.4.1",
     "react-compiler-runtime": "^1.0.0",
     "slate": "0.124.1",
     "slate-dom": "0.124.1",
-    "slate-hyperscript": "0.100.0",
+    "slate-hyperscript": "0.125.0",
     "slate-react": "0.124.2",
     "use-deep-compare": "^1.3.0",
     "zustand": "^5.0.5",
     "zustand-x": "6.2.1",
-    "@platejs/slate": "npm:@lofcz/platejs-slate@53.1.1",
+    "@platejs/slate": "npm:@lofcz/platejs-slate@53.1.7",
     "@udecode/react-hotkeys": "npm:@lofcz/udecode-react-hotkeys@52.3.6",
     "@udecode/react-utils": "npm:@lofcz/udecode-react-utils@52.3.4",
     "@udecode/utils": "npm:@lofcz/udecode-utils@52.3.4"