@lofcz/platejs-core 53.1.6 → 53.1.8

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 SlateElement, Ao as pluginRenderElementStatic, Ba as pipeDecorate, Co as pipeRenderTextStatic, Do as pluginRenderLeafStatic, Eo as pipeRenderLeafStatic, Ga as getRenderNodeStaticProps, Ha as getSelectedDomNode, Ja as createStaticString, Ka as getNodeDataAttributes, Oo as pipeRenderElementStatic, Qa as getEditorDOMFromHtmlString, Ra as stripSlateDataAttributes, So as SlateRenderText, To as SlateRenderLeaf, Ua as getSelectedDomFragment, Va as isSelectOutside, Wa as getSelectedDomBlocks, Xa as ViewPlugin, Ya as getStaticPlugins, Za as createStaticEditor, _o as serializeHtml, ao as SlateText, bo as PlateStatic, co as StyledSlateLeafProps, do as BoxStaticProps, eo as SlateElementProps, fo as SlateRenderElementProps, go as SerializeHtmlOptions, ho as SlateRenderTextProps, io as SlateNodeProps, ko as SlateRenderElement, lo as StyledSlateTextProps, mo as SlateRenderNodeProps, no as SlateLeaf, oo as SlateTextProps, po as SlateRenderLeafProps, qa as getPluginDataAttributes, ro as SlateLeafProps, so as StyledSlateElementProps, to as SlateHTMLProps, uo as useNodeAttributes, vo as ElementStatic, wo as pluginRenderTextStatic, xo as PlateStaticProps, yo as LeafStatic, za as stripHtmlClassNames } from "../index-BDSzA1zP";
 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-NVP0S9vL.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-KMalmfNw.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-KMalmfNw.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 { St as keyToDataAttribute, bt as getPluginNodeProps, n as withSlate, ot as DOMPlugin, p as isEditOnly, sn as getEditorPlugin, tn as getPluginByType, wt as getInjectMatch, yt as getSlateClass } from "./withSlate-NVP0S9vL.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-NVP0S9vL.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";
@@ -788,7 +787,7 @@ const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore)
 			textProps: [],
 			types: {}
 		},
-		normalizeInitialValue: [],
+		transformInitialValue: [],
 		render: {
 			aboveEditable: [],
 			aboveNodes: [],
@@ -829,7 +828,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 +1455,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 +2721,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 +2729,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 +2776,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 +2860,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 +2964,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();
+	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 +3016,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 +3079,7 @@ const pipeOnTextChange = (editor, node, text, prevText, operation) => {
 const DEFAULT = {
 	handlers: true,
 	inject: true,
-	normalizeInitialValue: false,
+	transformInitialValue: false,
 	render: true
 };
 /**
@@ -2967,29 +3089,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 +3140,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,
@@ -3671,4 +3807,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 { collapseString as $, defineInputRule as $t, deserializeHtml as A, isSlatePluginElement as At, getDataNodeProps as B, withDeleteRules as Bt, flashTarget as C, getInjectedPlugins as Ct, LengthPlugin as D, isSlateElement as Dt, NavigationFeedbackPluginKey as E, isSlateEditor as Et, htmlElementToLeaf as F, applyDeepToNodes as Ft, collapseWhiteSpaceElement as G, AstPlugin as Gt, htmlBodyToFragment as H, BaseParagraphPlugin as Ht, pipeDeserializeHtmlLeaf as I, OverridePlugin as It, collapseWhiteSpaceNode as J, createMarkInputRule as Jt, inferWhiteSpaceRule as K, createBlockFenceInputRule as Kt, htmlElementToElement as L, withOverrides as Lt, deserializeHtmlElement as M, isSlateString as Mt, deserializeHtmlNode as N, isSlateText as Nt, HtmlPlugin as O, isSlateLeaf as Ot, htmlTextNodeToString as P, isSlateVoid as Pt, isLastNonEmptyTextOfInlineFormattingContext as Q, matchDelimitedInline as Qt, pipeDeserializeHtmlElement as R, withNormalizeRules as Rt, clearNavigationFeedbackTarget as S, keyToDataAttribute as St, NAVIGATION_FEEDBACK_KEY as T, getSlateElements as Tt, deserializeHtmlNodeChildren as U, HistoryPlugin as Ut, htmlBrToNewLine as V, withBreakRules as Vt, collapseWhiteSpace as W, withPlateHistory as Wt, endInlineFormattingContext as X, matchBlockFence as Xt, collapseWhiteSpaceText as Y, createTextSubstitutionInputRule as Yt, upsertInlineFormattingContext as Z, matchBlockStart as Zt, normalizeNodeId as _, getEdgeNodes as _t, pipeInsertDataQuery as a, getPluginTypes as an, AUTO_SCROLL as at, NavigationFeedbackPlugin as b, getPluginNodeProps as bt, setValue as c, createSlatePlugin as cn, DebugPlugin as ct, insertExitBreak as d, withChunking as dt, getContainerTypes as en, isHtmlBlockElement as et, init as f, AffinityPlugin as ft, NodeIdPlugin as g, getMarkBoundaryAffinity as gt, pipeOnNodeChange as h, isNodesAffinity as ht, ParserPlugin as i, getPluginType as in, isHtmlElement as it, htmlStringToDOMNode as j, isSlatePluginNode as jt, parseHtmlDocument as k, isSlateNode as kt, resetBlock as l, createTSlatePlugin as ln, PlateError as lt, pipeOnTextChange as m, isNodeAffinity as mt, withSlate as n, getPluginKey as nn, inlineTagNames as nt, normalizeDescendantsToDocumentFragment as o, getSlatePlugin as on, DOMPlugin as ot, isEditOnly as p, setAffinitySelection as pt, collapseWhiteSpaceChildren as q, createBlockStartInputRule as qt, getCorePlugins as r, getPluginKeys as rn, isHtmlText as rt, SlateExtensionPlugin as s, getEditorPlugin as sn, withScrolling as st, createSlateEditor as t, getPluginByType as tn, isHtmlInlineElement as tt, liftBlock as u, ChunkingPlugin as ut, normalizeNodeIdWithEditor as v, mergeDeepToNodes as vt, resolveNavigationFeedbackTarget as w, getInjectMatch as wt, navigate as x, getNodeDataAttributeKeys as xt, withNodeId as y, getSlateClass as yt, pluginDeserializeHtml as z, withMergeRules as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-core",
-  "version": "53.1.6",
+  "version": "53.1.8",
   "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"