smartrte-core 0.2.1 → 1.0.0-beta.1

package/dist/legacyCommands/list.js

@@ -0,0 +1,477 @@
+import { getNodeAtPath, paragraph, } from "../model.js";
+import { listFromBlocks } from "../table.js";
+import { replaceNodeAtPath } from "../tree.js";
+import { resolveListSelectionScope } from "../listScope.js";
+import { listStyleForPresetDepth } from "../listPresets.js";
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const isBlock = (node) => Boolean(node) && typeof node === "object" &&
+    ["paragraph", "heading", "list", "blockquote", "codeBlock", "table"]
+        .includes(node.type || "");
+const selectionPaths = (selection) => {
+    if (selection.type === "text")
+        return [selection.anchor.path, selection.focus.path];
+    if (selection.type === "node")
+        return [selection.path, selection.path];
+    return null;
+};
+const structuralUnit = (document, path) => {
+    let firstBlockPath = null;
+    for (let depth = 1; depth <= path.length; depth += 1) {
+        const candidatePath = path.slice(0, depth);
+        const node = getNodeAtPath(document, candidatePath);
+        if (!isBlock(node))
+            continue;
+        if (!firstBlockPath)
+            firstBlockPath = candidatePath;
+        if (node.type === "list") {
+            const itemIndex = path[depth];
+            return {
+                path: candidatePath,
+                ...(Number.isInteger(itemIndex) ? { listItemIndex: itemIndex } : {}),
+            };
+        }
+        // A table is a container boundary, not a selectable text block.
+        if (node.type === "table")
+            firstBlockPath = null;
+    }
+    return firstBlockPath ? { path: firstBlockPath } : null;
+};
+const resolveListTarget = (context) => {
+    const scope = resolveListSelectionScope(context.document, context.selection);
+    if (scope.kind === "none")
+        return null;
+    if (scope.kind === "all")
+        return { kind: "range", containerPath: [], start: 0, end: context.document.children.length - 1 };
+    if (scope.kind === "blocks")
+        return { kind: "range", containerPath: scope.containerPath, start: scope.start, end: scope.end };
+    if (scope.kind === "list")
+        return { kind: "items", listPath: scope.listPath, start: scope.start, end: scope.end };
+    if (scope.kind === "mixed")
+        return { kind: "mixed", containerPath: scope.containerPath, blockIndex: scope.blockIndex, listPath: scope.listPath, itemStart: scope.itemStart, itemEnd: scope.itemEnd };
+    return null;
+};
+const itemFromBlock = (block) => ({
+    type: "listItem",
+    children: [block],
+});
+const blocksFromItem = (item) => item.children.length ? item.children : [paragraph()];
+const replaceContainerChildren = (document, containerPath, children) => {
+    const container = getNodeAtPath(document, containerPath);
+    if (!container?.children)
+        throw new Error("List selection does not resolve to a block container.");
+    return replaceNodeAtPath(document, containerPath, { ...container, children });
+};
+const transformBlockRange = (document, target, style, forceList = false) => {
+    const container = getNodeAtPath(document, target.containerPath);
+    if (!container?.children || target.start < 0 || target.end >= container.children.length) {
+        throw new Error("Selected block range is out of bounds.");
+    }
+    const selected = container.children.slice(target.start, target.end + 1);
+    const allSameStyleLists = selected.every((block) => block.type === "list" && block.style === style);
+    const replacement = allSameStyleLists && !forceList
+        ? selected.flatMap((block) => block.type === "list" ? block.children.flatMap(blocksFromItem) : [block])
+        : [{
+                type: "list",
+                style,
+                children: selected.flatMap((block) => block.type === "list" ? block.children : [itemFromBlock(block)]),
+            }];
+    const children = [
+        ...container.children.slice(0, target.start),
+        ...replacement,
+        ...container.children.slice(target.end + 1),
+    ];
+    return {
+        document: replaceContainerChildren(document, target.containerPath, children),
+        path: [...target.containerPath, target.start],
+    };
+};
+const transformListItems = (document, target, style) => {
+    const list = getNodeAtPath(document, target.listPath);
+    if (!list || list.type !== "list" || target.start < 0 || target.end >= list.children.length) {
+        throw new Error("Selected list-item range is out of bounds.");
+    }
+    const before = list.children.slice(0, target.start);
+    const selected = list.children.slice(target.start, target.end + 1);
+    const after = list.children.slice(target.end + 1);
+    const parentPath = target.listPath.slice(0, -1);
+    const listIndex = target.listPath[target.listPath.length - 1];
+    const parent = getNodeAtPath(document, parentPath);
+    if (!parent?.children)
+        throw new Error("List parent is not a block container.");
+    const replacement = [];
+    if (before.length)
+        replacement.push({ ...list, children: before });
+    if (list.style === style) {
+        replacement.push(...selected.flatMap(blocksFromItem));
+    }
+    else {
+        replacement.push({ ...list, style, children: selected });
+    }
+    if (after.length)
+        replacement.push({ ...list, children: after });
+    const children = [
+        ...parent.children.slice(0, listIndex),
+        ...replacement,
+        ...parent.children.slice(listIndex + 1),
+    ];
+    return {
+        document: replaceContainerChildren(document, parentPath, children),
+        path: [...parentPath, listIndex + (before.length ? 1 : 0)],
+    };
+};
+const transformMixedRange = (document, target, style) => {
+    const container = getNodeAtPath(document, target.containerPath);
+    const source = getNodeAtPath(document, target.listPath);
+    if (!container?.children || source?.type !== "list")
+        throw new Error("Mixed list selection is invalid.");
+    const selectedItems = source.children.slice(target.itemStart, target.itemEnd + 1);
+    const mixedList = {
+        type: "list",
+        style,
+        children: [
+            itemFromBlock(container.children[target.blockIndex]),
+            ...selectedItems,
+        ],
+    };
+    const remaining = source.children.filter((_, index) => index < target.itemStart || index > target.itemEnd);
+    const replacement = remaining.length > 0
+        ? [mixedList, { ...source, children: remaining }]
+        : [mixedList];
+    const children = [...container.children];
+    children.splice(Math.min(target.blockIndex, target.listPath[target.listPath.length - 1]), 2, ...replacement);
+    return {
+        document: replaceContainerChildren(document, target.containerPath, children),
+        path: [...target.containerPath, Math.min(target.blockIndex, target.listPath[target.listPath.length - 1])],
+    };
+};
+const cascadeListStyles = (list, depth = 0) => {
+    if (list.preset) {
+        return {
+            ...list,
+            style: listStyleForPresetDepth(list.preset, depth),
+            children: list.children.map((item) => ({
+                ...item,
+                children: item.children.map((child) => child.type === "list"
+                    ? cascadeListStyles({ ...child, preset: list.preset }, depth + 1)
+                    : child),
+            })),
+        };
+    }
+    const ordered = ["decimal", "lower-alpha", "lower-roman", "upper-alpha", "upper-roman"];
+    const unordered = ["disc", "circle", "square"];
+    const orderedStyle = list.style === "decimal-leading-zero" || ordered.includes(list.style);
+    const family = orderedStyle ? ordered : unordered;
+    const style = depth === 0 ? list.style : family[Math.min(depth, family.length - 1)];
+    return {
+        ...list,
+        style,
+        children: list.children.map((item) => ({
+            ...item,
+            children: item.children.map((child) => child.type === "list" ? cascadeListStyles({ ...child, style }, depth + 1) : child),
+        })),
+    };
+};
+export const toggleList = {
+    id: "list.toggle",
+    isEnabled: (context, input) => Boolean(input && resolveListTarget(context)),
+    execute: (context, input) => {
+        if (!input)
+            throw new Error("list.toggle requires a list style.");
+        const target = resolveListTarget(context);
+        if (!target)
+            throw new Error("list.toggle requires a compatible block selection.");
+        const effectiveTarget = target.kind === "items" && input.scope !== "selected-items"
+            ? {
+                kind: "range",
+                containerPath: target.listPath.slice(0, -1),
+                start: target.listPath[target.listPath.length - 1],
+                end: target.listPath[target.listPath.length - 1],
+            }
+            : target;
+        const selectedNode = effectiveTarget.kind === "range" && effectiveTarget.start === effectiveTarget.end
+            ? getNodeAtPath(context.document, [...effectiveTarget.containerPath, effectiveTarget.start])
+            : null;
+        if (input.checklist &&
+            effectiveTarget.kind === "range" &&
+            selectedNode?.type === "list" &&
+            selectedNode.checklist) {
+            const list = selectedNode;
+            const document = replaceNodeAtPath(context.document, [...effectiveTarget.containerPath, effectiveTarget.start], {
+                ...list,
+                checklist: undefined,
+                strikeCompleted: undefined,
+                children: list.children.map((item) => ({ ...item, checked: undefined })),
+            });
+            return {
+                id: "list.toggle",
+                source: "user",
+                operations: [{ type: "replaceNode", path: [], node: document }],
+                selectionBefore: context.selection,
+                selectionAfter: context.selection,
+                addToHistory: true,
+                timestamp: context.now?.() ?? Date.now(),
+            };
+        }
+        let result = effectiveTarget.kind === "range"
+            ? transformBlockRange(context.document, effectiveTarget, input.style, input.checklist || Boolean(input.preset))
+            : effectiveTarget.kind === "items"
+                ? transformListItems(context.document, effectiveTarget, input.style)
+                : transformMixedRange(context.document, effectiveTarget, input.style);
+        if (input.preset) {
+            const transformed = getNodeAtPath(result.document, result.path);
+            if (transformed?.type === "list") {
+                const list = transformed;
+                result = {
+                    ...result,
+                    document: replaceNodeAtPath(result.document, result.path, {
+                        ...list,
+                        preset: input.preset,
+                        style: listStyleForPresetDepth(input.preset, 0),
+                    }),
+                };
+            }
+        }
+        if (input.checklist) {
+            const transformed = getNodeAtPath(result.document, result.path);
+            if (transformed?.type === "list") {
+                const list = transformed;
+                result = {
+                    ...result,
+                    document: replaceNodeAtPath(result.document, result.path, {
+                        ...list,
+                        checklist: true,
+                        ...(input.strikeCompleted ? { strikeCompleted: true } : {}),
+                        children: list.children.map((item) => ({
+                            ...item,
+                            checked: item.checked ?? false,
+                        })),
+                    }),
+                };
+            }
+        }
+        if (input.cascadeStyles) {
+            const transformed = getNodeAtPath(result.document, result.path);
+            if (transformed?.type === "list") {
+                result = {
+                    ...result,
+                    document: replaceNodeAtPath(result.document, result.path, cascadeListStyles(transformed)),
+                };
+            }
+        }
+        return {
+            id: "list.toggle",
+            source: "user",
+            operations: [{ type: "replaceNode", path: [], node: result.document }],
+            selectionBefore: context.selection,
+            selectionAfter: { type: "node", path: result.path },
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+const deepestListUnit = (document, path) => {
+    let result = null;
+    for (let depth = 1; depth < path.length; depth += 1) {
+        const listPath = path.slice(0, depth);
+        const node = getNodeAtPath(document, listPath);
+        if (node?.type === "list" && Number.isInteger(path[depth])) {
+            result = { listPath, itemIndex: path[depth] };
+        }
+    }
+    return result;
+};
+const listItemTarget = (context) => {
+    const paths = selectionPaths(context.selection);
+    if (!paths)
+        return null;
+    const anchor = deepestListUnit(context.document, paths[0]);
+    const focus = deepestListUnit(context.document, paths[1]);
+    if (!anchor || !focus || !samePath(anchor.listPath, focus.listPath))
+        return null;
+    return {
+        kind: "items",
+        listPath: anchor.listPath,
+        start: Math.min(anchor.itemIndex, focus.itemIndex),
+        end: Math.max(anchor.itemIndex, focus.itemIndex),
+    };
+};
+const listTransaction = (id, context, document, selectionAfter) => ({
+    id,
+    source: "user",
+    operations: [{ type: "replaceNode", path: [], node: document }],
+    selectionBefore: context.selection,
+    selectionAfter,
+    addToHistory: true,
+    timestamp: context.now?.() ?? Date.now(),
+});
+const pathStartsWith = (path, prefix) => prefix.length <= path.length && prefix.every((part, index) => path[index] === part);
+const mapSelectedTextItems = (selection, listPath, start, end, mapPath) => {
+    if (selection.type !== "text")
+        return null;
+    const mapPoint = (point) => {
+        if (!pathStartsWith(point.path, listPath) || point.path.length <= listPath.length)
+            return null;
+        const itemIndex = point.path[listPath.length];
+        if (itemIndex < start || itemIndex > end)
+            return null;
+        return {
+            path: mapPath(itemIndex, point.path.slice(listPath.length + 1)),
+            offset: point.offset,
+        };
+    };
+    const anchor = mapPoint(selection.anchor);
+    const focus = mapPoint(selection.focus);
+    return anchor && focus ? { type: "text", anchor, focus } : null;
+};
+export const indentListItems = {
+    id: "list.indent",
+    isEnabled: (context) => {
+        const target = listItemTarget(context);
+        return Boolean(target && target.start > 0);
+    },
+    execute: (context) => {
+        const target = listItemTarget(context);
+        if (!target || target.start === 0) {
+            throw new Error("list.indent requires list items with a previous sibling.");
+        }
+        const list = getNodeAtPath(context.document, target.listPath);
+        const previous = list.children[target.start - 1];
+        const selected = list.children.slice(target.start, target.end + 1);
+        const lastChild = previous.children[previous.children.length - 1];
+        const existingNestedCount = lastChild?.type === "list" && lastChild.style === list.style
+            ? lastChild.children.length
+            : 0;
+        const nested = lastChild?.type === "list" && lastChild.style === list.style
+            ? { ...lastChild, children: [...lastChild.children, ...selected] }
+            : { type: "list", style: list.style, children: selected };
+        const previousChildren = lastChild?.type === "list" && lastChild.style === list.style
+            ? [...previous.children.slice(0, -1), nested]
+            : [...previous.children, nested];
+        const nextList = {
+            ...list,
+            children: [
+                ...list.children.slice(0, target.start - 1),
+                { ...previous, children: previousChildren },
+                ...list.children.slice(target.end + 1),
+            ],
+        };
+        const document = replaceNodeAtPath(context.document, target.listPath, nextList);
+        const selectionAfter = mapSelectedTextItems(context.selection, target.listPath, target.start, target.end, (itemIndex, suffix) => [
+            ...target.listPath,
+            target.start - 1,
+            previousChildren.length - 1,
+            existingNestedCount + itemIndex - target.start,
+            ...suffix,
+        ]) || { type: "node", path: [...target.listPath, target.start - 1, previousChildren.length - 1] };
+        return listTransaction("list.indent", context, document, selectionAfter);
+    },
+};
+export const outdentListItems = {
+    id: "list.outdent",
+    isEnabled: (context) => {
+        const target = listItemTarget(context);
+        if (!target || target.listPath.length < 3)
+            return false;
+        const parentItemPath = target.listPath.slice(0, -1);
+        const parentItem = getNodeAtPath(context.document, parentItemPath);
+        const ancestorList = getNodeAtPath(context.document, parentItemPath.slice(0, -1));
+        return parentItem?.type === "listItem" &&
+            ancestorList?.type === "list";
+    },
+    execute: (context) => {
+        const target = listItemTarget(context);
+        if (!target || !outdentListItems.isEnabled(context)) {
+            throw new Error("list.outdent requires items in a nested list.");
+        }
+        const nestedList = getNodeAtPath(context.document, target.listPath);
+        const parentItemPath = target.listPath.slice(0, -1);
+        const parentItem = getNodeAtPath(context.document, parentItemPath);
+        const ancestorListPath = parentItemPath.slice(0, -1);
+        const ancestorList = getNodeAtPath(context.document, ancestorListPath);
+        const parentIndex = parentItemPath[parentItemPath.length - 1];
+        const nestedIndex = target.listPath[target.listPath.length - 1];
+        const selected = nestedList.children.slice(target.start, target.end + 1);
+        const remaining = [
+            ...nestedList.children.slice(0, target.start),
+            ...nestedList.children.slice(target.end + 1),
+        ];
+        const nextParent = {
+            ...parentItem,
+            children: remaining.length
+                ? [
+                    ...parentItem.children.slice(0, nestedIndex),
+                    { ...nestedList, children: remaining },
+                    ...parentItem.children.slice(nestedIndex + 1),
+                ]
+                : [
+                    ...parentItem.children.slice(0, nestedIndex),
+                    ...parentItem.children.slice(nestedIndex + 1),
+                ],
+        };
+        const nextAncestor = {
+            ...ancestorList,
+            children: [
+                ...ancestorList.children.slice(0, parentIndex),
+                nextParent,
+                ...selected,
+                ...ancestorList.children.slice(parentIndex + 1),
+            ],
+        };
+        const document = replaceNodeAtPath(context.document, ancestorListPath, nextAncestor);
+        const selectionAfter = mapSelectedTextItems(context.selection, target.listPath, target.start, target.end, (itemIndex, suffix) => [
+            ...ancestorListPath,
+            parentIndex + 1 + itemIndex - target.start,
+            ...suffix,
+        ]) || { type: "node", path: [...ancestorListPath, parentIndex + 1] };
+        return listTransaction("list.outdent", context, document, selectionAfter);
+    },
+};
+/**
+ * Converts explicitly selected block nodes in one table cell into a single
+ * list. No DOM ranges, wrappers, or React state participate in this command.
+ */
+export const toggleTableCellList = (document, selection, input) => {
+    const table = getNodeAtPath(document, input.tablePath);
+    if (!table || table.type !== "table")
+        throw new Error("Expected a table at tablePath.");
+    const cell = table.children[input.row]?.children[input.column];
+    if (!cell || (cell.type !== "tableCell" && cell.type !== "tableHeaderCell")) {
+        throw new Error("Expected a table cell at the requested coordinates.");
+    }
+    const indexes = [...new Set(input.blockIndexes)].sort((left, right) => left - right);
+    if (indexes.length === 0)
+        throw new Error("At least one table-cell block must be selected.");
+    if (indexes.some((index) => index < 0 || index >= cell.children.length)) {
+        throw new Error("Selected table-cell block index is out of bounds.");
+    }
+    const selected = indexes.map((index) => cell.children[index]);
+    const selectedIndexes = new Set(indexes);
+    const firstIndex = indexes[0];
+    const list = listFromBlocks(selected, input.style);
+    const nextCell = {
+        ...cell,
+        children: cell.children.reduce((children, block, index) => {
+            if (index === firstIndex)
+                children.push(list);
+            if (!selectedIndexes.has(index))
+                children.push(block);
+            return children;
+        }, []),
+    };
+    const cellPath = [...input.tablePath, input.row, input.column];
+    const nextDocument = replaceNodeAtPath(document, cellPath, nextCell);
+    const listPath = [...cellPath, firstIndex];
+    const selectionAfter = { type: "node", path: listPath };
+    return {
+        document: nextDocument,
+        transaction: {
+            id: "toggle-table-cell-list",
+            source: "user",
+            operations: [{ type: "replaceNode", path: cellPath, node: nextCell }],
+            selectionBefore: selection,
+            selectionAfter,
+            addToHistory: true,
+            timestamp: Date.now(),
+        },
+    };
+};

package/dist/{commands → legacyCommands}/marks.d.ts

@@ -2,11 +2,14 @@ import type { SmartCommand } from "../command.js";
 export declare const toggleBold: SmartCommand<void>;
 export declare const toggleItalic: SmartCommand<void>;
 export declare const toggleUnderline: SmartCommand<void>;
+export declare const toggleStrike: SmartCommand<void>;
+export declare const toggleInlineCode: SmartCommand<void>;
 export declare const toggleSuperscript: SmartCommand<void>;
 export declare const toggleSubscript: SmartCommand<void>;
 export declare const applyTextColor: SmartCommand<string>;
 export declare const applyBackgroundColor: SmartCommand<string>;
 export declare const applyFontSize: SmartCommand<number>;
+export declare const applyFontFamily: SmartCommand<string>;
 type LinkInput = {
     href: string;
     target?: string;

package/dist/{commands → legacyCommands}/marks.js

@@ -1,5 +1,5 @@
 import { addMark, hasMark, removeMark } from "../marks.js";
-import { getNodeAtPath } from "../model.js";
+import { getNodeAtPath, } from "../model.js";
 import { sanitizeLinkAttrs } from "../security/urlPolicy.js";
 const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
 const getTextRange = (context) => {
@@ -20,11 +20,15 @@ const getTextRange = (context) => {
     const nodes = parent?.children;
     if (!nodes || startIndex < 0 || endIndex >= nodes.length || startOffset < 0 || endOffset < 0)
         return null;
-    if (nodes.slice(startIndex, endIndex + 1).some((node) => node.type !== "text"))
+    const startNode = nodes[startIndex];
+    const endNode = nodes[endIndex];
+    if (startNode?.type !== "text" || endNode?.type !== "text")
         return null;
-    if (startIndex === endIndex && (startOffset === endOffset || endOffset > nodes[startIndex].text.length))
+    if (startIndex === endIndex && (startOffset === endOffset || endOffset > startNode.text.length))
         return null;
-    if (startOffset > nodes[startIndex].text.length || endOffset > nodes[endIndex].text.length)
+    if (startOffset > startNode.text.length || endOffset > endNode.text.length)
+        return null;
+    if (!nodes.slice(startIndex, endIndex + 1).some((node) => node.type === "text"))
         return null;
     return { selection: context.selection, parentPath, startIndex, endIndex, startOffset, endOffset, nodes };
 };
@@ -37,6 +41,10 @@ const replaceRange = (range, mutate) => {
             children.push(node);
             return;
         }
+        if (node.type !== "text") {
+            children.push(node);
+            return;
+        }
         const from = index === range.startIndex ? range.startOffset : 0;
         const to = index === range.endIndex ? range.endOffset : node.text.length;
         if (from > 0)
@@ -54,16 +62,23 @@ const replaceRange = (range, mutate) => {
     return { children, start: selectionStart, end: selectionEnd };
 };
 const hasLink = (marks) => marks?.some((mark) => mark.type === "link") || false;
+const selectedTextNodes = (range) => range.nodes
+    .slice(range.startIndex, range.endIndex + 1)
+    .filter((node) => node.type === "text");
 const createMarkTransaction = (id, context, input, mutate) => {
     const range = getTextRange(context);
     if (!range)
         throw new Error(`${id} requires text in one inline container.`);
     const result = replaceRange(range, (marks) => mutate(marks, range));
     const parent = getNodeAtPath(context.document, range.parentPath);
+    const selectionEnd = result.children[result.end];
     const selectionAfter = {
         type: "text",
         anchor: { path: [...range.parentPath, result.start], offset: 0 },
-        focus: { path: [...range.parentPath, result.end], offset: result.children[result.end]?.text.length || 0 },
+        focus: {
+            path: [...range.parentPath, result.end],
+            offset: selectionEnd?.type === "text" ? selectionEnd.text.length : 0,
+        },
     };
     return {
         id,
@@ -83,7 +98,7 @@ const createMarkCommand = (id, nextMark, toggle) => ({
         if (!range)
             throw new Error(`${id} requires text in one inline container.`);
         const mark = nextMark(input);
-        const selected = range.nodes.slice(range.startIndex, range.endIndex + 1);
+        const selected = selectedTextNodes(range);
         const remove = toggle && selected.every((node) => hasMark(node.marks, mark.type));
         return createMarkTransaction(id, context, input, (marks) => remove ? removeMark(marks, mark.type) : addMark(marks, mark));
     },
@@ -96,8 +111,7 @@ const toggleScript = (id, type) => ({
         const range = getTextRange(context);
         if (!range)
             throw new Error(`${id} requires text in one inline container.`);
-        const remove = range.nodes
-            .slice(range.startIndex, range.endIndex + 1)
+        const remove = selectedTextNodes(range)
             .every((node) => hasMark(node.marks, type));
         const opposite = type === "superscript" ? "subscript" : "superscript";
         return createMarkTransaction(id, context, undefined, (marks) => {
@@ -109,11 +123,14 @@ const toggleScript = (id, type) => ({
 export const toggleBold = toggle("toggle-bold", "bold");
 export const toggleItalic = toggle("toggle-italic", "italic");
 export const toggleUnderline = toggle("toggle-underline", "underline");
+export const toggleStrike = toggle("toggle-strike", "strike");
+export const toggleInlineCode = toggle("toggle-inline-code", "code");
 export const toggleSuperscript = toggleScript("toggle-superscript", "superscript");
 export const toggleSubscript = toggleScript("toggle-subscript", "subscript");
 export const applyTextColor = createMarkCommand("apply-text-color", (value) => ({ type: "textColor", value }), false);
 export const applyBackgroundColor = createMarkCommand("apply-background-color", (value) => ({ type: "backgroundColor", value }), false);
 export const applyFontSize = createMarkCommand("apply-font-size", (valuePx) => ({ type: "fontSize", valuePx }), false);
+export const applyFontFamily = createMarkCommand("apply-font-family", (value) => ({ type: "fontFamily", value }), false);
 export const applyLink = {
     id: "apply-link",
     isEnabled: (context, input) => Boolean(getTextRange(context) && input && sanitizeLinkAttrs(input)),
@@ -128,12 +145,12 @@ export const updateLink = {
     id: "update-link",
     isEnabled: (context, input) => {
         const range = getTextRange(context);
-        return Boolean(range && input && sanitizeLinkAttrs(input) && range.nodes.slice(range.startIndex, range.endIndex + 1).some((node) => hasLink(node.marks)));
+        return Boolean(range && input && sanitizeLinkAttrs(input) && selectedTextNodes(range).some((node) => hasLink(node.marks)));
     },
     execute: (context, input) => {
         const range = getTextRange(context);
         const safe = sanitizeLinkAttrs(input || {});
-        if (!range || !safe || !range.nodes.slice(range.startIndex, range.endIndex + 1).some((node) => hasLink(node.marks))) {
+        if (!range || !safe || !selectedTextNodes(range).some((node) => hasLink(node.marks))) {
             throw new Error("update-link requires selected linked text and a safe href.");
         }
         return createMarkTransaction("update-link", context, input, (marks) => addMark(marks, { type: "link", ...safe }));
@@ -143,7 +160,7 @@ export const removeLink = {
     id: "remove-link",
     isEnabled: (context) => {
         const range = getTextRange(context);
-        return Boolean(range && range.nodes.slice(range.startIndex, range.endIndex + 1).some((node) => hasLink(node.marks)));
+        return Boolean(range && selectedTextNodes(range).some((node) => hasLink(node.marks)));
     },
     execute: (context) => {
         if (!removeLink.isEnabled(context))

package/dist/legacyCommands/media.d.ts

@@ -0,0 +1,31 @@
+import type { SmartCommand } from "../command.js";
+import { type Path } from "../model.js";
+export interface InsertImageInput {
+    src: string;
+    alt?: string;
+    title?: string;
+    width?: number;
+    height?: number;
+    path?: Path;
+}
+export interface InsertInlineImageInput extends InsertImageInput {
+}
+export declare const insertImage: SmartCommand<InsertImageInput>;
+export declare const insertInlineImage: SmartCommand<InsertInlineImageInput>;
+export declare const deleteInlineImage: SmartCommand<import("./inlineAtoms.js").InlineAtomPathInput>;
+export interface UpdateInlineImageInput {
+    path: Path;
+    alt?: string;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+export declare const updateInlineImage: SmartCommand<UpdateInlineImageInput>;
+export interface InsertMediaInput {
+    src: string;
+    mediaType: "audio" | "video" | "file";
+    title?: string;
+    mimeType?: string;
+    path?: Path;
+}
+export declare const insertMedia: SmartCommand<InsertMediaInput>;