smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/selectionMapping.js

@@ -0,0 +1,222 @@
+import { getNodeAtTreePath, isSmartContainer } from "./tree.js";
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const hasPrefix = (path, prefix) => path.length >= prefix.length && prefix.every((part, index) => path[index] === part);
+const insertionAdjustedPath = (path, insertion) => {
+    const parent = insertion.slice(0, -1);
+    const depth = parent.length;
+    if (!hasPrefix(path, parent) || path.length <= depth)
+        return [...path];
+    const next = [...path];
+    if (next[depth] >= insertion[depth])
+        next[depth] += 1;
+    return next;
+};
+const removalAdjustedPath = (path, removal) => {
+    if (hasPrefix(path, removal))
+        return null;
+    const parent = removal.slice(0, -1);
+    const depth = parent.length;
+    if (!hasPrefix(path, parent) || path.length <= depth)
+        return [...path];
+    const next = [...path];
+    if (next[depth] > removal[depth])
+        next[depth] -= 1;
+    return next;
+};
+const moveDestinationAfterRemoval = (from, to) => {
+    const parent = from.slice(0, -1);
+    const depth = parent.length;
+    const next = [...to];
+    if (hasPrefix(to, parent) && to.length > depth && from[depth] < to[depth])
+        next[depth] -= 1;
+    return next;
+};
+const moveAdjustedPath = (path, from, to) => {
+    const destination = moveDestinationAfterRemoval(from, to);
+    if (hasPrefix(path, from))
+        return [...destination, ...path.slice(from.length)];
+    const afterRemoval = removalAdjustedPath(path, from);
+    return afterRemoval ? insertionAdjustedPath(afterRemoval, destination) : null;
+};
+const splitAdjustedPath = (path, splitPath, position) => {
+    const parent = splitPath.slice(0, -1);
+    const depth = splitPath.length - 1;
+    const rightPath = [...parent, splitPath[depth] + 1];
+    if (hasPrefix(path, splitPath) && path.length > splitPath.length) {
+        const childIndex = path[splitPath.length];
+        return childIndex >= position
+            ? [...rightPath, childIndex - position, ...path.slice(splitPath.length + 1)]
+            : [...path];
+    }
+    if (hasPrefix(path, parent) && path.length > depth && path[depth] > splitPath[depth]) {
+        const next = [...path];
+        next[depth] += 1;
+        return next;
+    }
+    return [...path];
+};
+const mergeAdjustedPath = (path, rightPath, leftContentLength) => {
+    const parent = rightPath.slice(0, -1);
+    const depth = rightPath.length - 1;
+    const leftPath = [...parent, rightPath[depth] - 1];
+    if (hasPrefix(path, rightPath)) {
+        if (path.length === rightPath.length)
+            return leftPath;
+        return [
+            ...leftPath,
+            path[rightPath.length] + leftContentLength,
+            ...path.slice(rightPath.length + 1),
+        ];
+    }
+    if (hasPrefix(path, parent) && path.length > depth && path[depth] > rightPath[depth]) {
+        const next = [...path];
+        next[depth] -= 1;
+        return next;
+    }
+    return [...path];
+};
+const mapTextSplitPoint = (point, path, start, end, originalLength) => {
+    const before = start > 0 ? 1 : 0;
+    const selected = end > start ? 1 : 0;
+    const pieces = before + selected + (end < originalLength ? 1 : 0);
+    const index = path[path.length - 1];
+    const parent = path.slice(0, -1);
+    if (!samePath(point.path, path)) {
+        if (hasPrefix(point.path, parent) &&
+            point.path.length > parent.length &&
+            point.path[parent.length] > index) {
+            const mapped = [...point.path];
+            mapped[parent.length] += pieces - 1;
+            return { ...point, path: mapped };
+        }
+        return { ...point, path: [...point.path] };
+    }
+    if (point.offset <= start) {
+        return { path: [...parent, index], offset: point.offset };
+    }
+    if (point.offset <= end && selected) {
+        return { path: [...parent, index + before], offset: point.offset - start };
+    }
+    return {
+        path: [...parent, index + before + selected],
+        offset: Math.max(0, point.offset - end),
+    };
+};
+const mapPoint = (point, operation, documentBefore) => {
+    if (operation.type === "insertNode") {
+        return { ...point, path: insertionAdjustedPath(point.path, operation.path) };
+    }
+    if (operation.type === "removeNode") {
+        const path = removalAdjustedPath(point.path, operation.path);
+        return path ? { ...point, path } : null;
+    }
+    if (operation.type === "moveNode") {
+        const path = moveAdjustedPath(point.path, operation.from, operation.to);
+        return path ? { ...point, path } : null;
+    }
+    if (operation.type === "splitNode") {
+        const node = getNodeAtTreePath(documentBefore, operation.path);
+        if (samePath(point.path, operation.path) && node?.type === "text") {
+            if (point.offset <= operation.position)
+                return { ...point, path: [...point.path] };
+            const rightPath = [
+                ...operation.path.slice(0, -1),
+                operation.path[operation.path.length - 1] + 1,
+            ];
+            return { path: rightPath, offset: point.offset - operation.position };
+        }
+        return { ...point, path: splitAdjustedPath(point.path, operation.path, operation.position) };
+    }
+    if (operation.type === "mergeNode") {
+        const right = getNodeAtTreePath(documentBefore, operation.path);
+        const leftPath = [
+            ...operation.path.slice(0, -1),
+            operation.path[operation.path.length - 1] - 1,
+        ];
+        const left = getNodeAtTreePath(documentBefore, leftPath);
+        const leftLength = left?.type === "text"
+            ? left.text.length
+            : isSmartContainer(left)
+                ? left.children.length
+                : 0;
+        if (samePath(point.path, operation.path) && right?.type === "text") {
+            return { path: leftPath, offset: leftLength + point.offset };
+        }
+        return { ...point, path: mergeAdjustedPath(point.path, operation.path, leftLength) };
+    }
+    if (operation.type === "replaceText" && samePath(point.path, operation.path)) {
+        const replacedLength = operation.end - operation.start;
+        const delta = operation.text.length - replacedLength;
+        if (point.offset <= operation.start)
+            return { ...point, path: [...point.path] };
+        if (point.offset <= operation.end) {
+            return { ...point, path: [...point.path], offset: operation.start + operation.text.length };
+        }
+        return { ...point, path: [...point.path], offset: point.offset + delta };
+    }
+    if ((operation.type === "addMark" || operation.type === "removeMark")) {
+        const node = getNodeAtTreePath(documentBefore, operation.path);
+        return mapTextSplitPoint(point, operation.path, operation.start, operation.end, node.text.length);
+    }
+    return { ...point, path: [...point.path] };
+};
+const fallbackForRemovedPath = (path) => ({
+    type: "node",
+    path: path.length ? path.slice(0, -1) : [],
+});
+export const mapSelectionThroughOperation = (selection, operation, documentBefore) => {
+    if (operation.type === "setSelection")
+        return operation.selection;
+    if (selection.type === "all")
+        return selection;
+    if (selection.type === "node") {
+        let path = selection.path;
+        if (operation.type === "insertNode")
+            path = insertionAdjustedPath(path, operation.path);
+        else if (operation.type === "removeNode")
+            path = removalAdjustedPath(path, operation.path);
+        else if (operation.type === "moveNode")
+            path = moveAdjustedPath(path, operation.from, operation.to);
+        else if (operation.type === "splitNode")
+            path = splitAdjustedPath(path, operation.path, operation.position);
+        else if (operation.type === "mergeNode") {
+            const leftPath = [...operation.path.slice(0, -1), operation.path[operation.path.length - 1] - 1];
+            const left = getNodeAtTreePath(documentBefore, leftPath);
+            const length = isSmartContainer(left) ? left.children.length : 0;
+            path = mergeAdjustedPath(path, operation.path, length);
+        }
+        return path
+            ? { type: "node", path }
+            : fallbackForRemovedPath(operation.type === "removeNode" ? operation.path : selection.path);
+    }
+    if (selection.type === "cell") {
+        let tablePath = selection.tablePath;
+        if (operation.type === "insertNode")
+            tablePath = insertionAdjustedPath(tablePath, operation.path);
+        else if (operation.type === "removeNode")
+            tablePath = removalAdjustedPath(tablePath, operation.path);
+        else if (operation.type === "moveNode")
+            tablePath = moveAdjustedPath(tablePath, operation.from, operation.to);
+        else if (operation.type === "splitNode")
+            tablePath = splitAdjustedPath(tablePath, operation.path, operation.position);
+        else if (operation.type === "mergeNode") {
+            const leftPath = [...operation.path.slice(0, -1), operation.path[operation.path.length - 1] - 1];
+            const left = getNodeAtTreePath(documentBefore, leftPath);
+            tablePath = mergeAdjustedPath(tablePath, operation.path, isSmartContainer(left) ? left.children.length : 0);
+        }
+        return tablePath
+            ? { ...selection, tablePath }
+            : fallbackForRemovedPath(operation.type === "removeNode" ? operation.path : selection.tablePath);
+    }
+    const anchor = mapPoint(selection.anchor, operation, documentBefore);
+    const focus = mapPoint(selection.focus, operation, documentBefore);
+    if (!anchor || !focus) {
+        const removedPath = operation.type === "removeNode"
+            ? operation.path
+            : operation.type === "moveNode"
+                ? operation.from
+                : selection.anchor.path;
+        return fallbackForRemovedPath(removedPath);
+    }
+    return { type: "text", anchor, focus };
+};

package/dist/table.d.ts

@@ -1,9 +1,9 @@
-import { type SmartBlockNode, type SmartTableCellNode } from "./model.js";
+import { type SmartBlockNode, type SmartListStyle, type SmartTableCellNode } from "./model.js";
 /** Ensures table cells have blocks even when imported HTML supplied raw lines. */
 export declare const normalizeTableCell: (cell: SmartTableCellNode, rawLines?: readonly string[]) => SmartTableCellNode;
-export declare const listFromBlocks: (blocks: readonly SmartBlockNode[], style?: "disc" | "circle" | "square" | "decimal" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman") => {
+export declare const listFromBlocks: (blocks: readonly SmartBlockNode[], style?: SmartListStyle) => {
     type: "list";
-    style: "disc" | "circle" | "square" | "decimal" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+    style: SmartListStyle;
     children: {
         type: "listItem";
         children: SmartBlockNode[];

package/dist/transaction.d.ts

@@ -1,7 +1,7 @@
-import type { SmartDocument, Path, SmartMark } from "./model.js";
-import type { SmartSelection } from "./selection.js";
+import type { LegacySmartDocument, Path, LegacySmartMark } from "./model.js";
+import type { LegacySmartSelection } from "./selection.js";
 import { type InlineMarkType } from "./marks.js";
-export type SmartOperation = {
+export type LegacySmartOperation = {
     type: "insertNode";
     path: Path;
     node: unknown;
@@ -12,16 +12,33 @@ export type SmartOperation = {
     type: "replaceNode";
     path: Path;
     node: unknown;
+} | {
+    type: "moveNode";
+    from: Path;
+    to: Path;
+} | {
+    type: "splitNode";
+    path: Path;
+    position: number;
+} | {
+    type: "mergeNode";
+    path: Path;
 } | {
     type: "setNodeAttrs";
     path: Path;
     attrs: Record<string, unknown>;
+} | {
+    type: "replaceText";
+    path: Path;
+    start: number;
+    end: number;
+    text: string;
 } | {
     type: "addMark";
     path: Path;
     start: number;
     end: number;
-    mark: SmartMark;
+    mark: LegacySmartMark;
 } | {
     type: "removeMark";
     path: Path;
@@ -30,19 +47,25 @@ export type SmartOperation = {
     markType: InlineMarkType;
 } | {
     type: "setSelection";
-    selection: SmartSelection;
+    selection: LegacySmartSelection;
 };
-export interface SmartTransaction {
+export interface LegacySmartTransaction {
     id: string;
     source: "user" | "paste" | "api" | "history" | "normalizer";
-    operations: SmartOperation[];
-    selectionBefore: SmartSelection;
-    selectionAfter: SmartSelection;
+    operations: LegacySmartOperation[];
+    selectionBefore: LegacySmartSelection;
+    selectionAfter?: LegacySmartSelection;
     addToHistory: boolean;
+    historyGroup?: string;
     timestamp: number;
 }
 export interface SmartEditorState {
-    document: SmartDocument;
-    selection: SmartSelection;
+    document: LegacySmartDocument;
+    selection: LegacySmartSelection;
 }
-export declare const applyTransaction: (state: SmartEditorState, transaction: SmartTransaction) => SmartEditorState;
+export declare const getMoveDestinationAfterRemoval: (from: Path, to: Path) => Path;
+export declare const applyOperationToState: (document: LegacySmartDocument, selection: LegacySmartSelection, operation: LegacySmartOperation) => {
+    document: LegacySmartDocument;
+    selection: LegacySmartSelection;
+};
+export declare const applyTransaction: (state: SmartEditorState, transaction: LegacySmartTransaction) => SmartEditorState;

package/dist/transaction.js

@@ -1,5 +1,7 @@
+import { mapSelectionThroughOperation } from "./selectionMapping.js";
+import { normalizeSmartDocument } from "./schema.js";
 import { addMark, removeMark } from "./marks.js";
-import { replaceNodeAtPath } from "./tree.js";
+import { getNodeAtTreePath, insertNodeAtPath, isSmartContainer, removeNodeAtPath, replaceNodeAtPath, } from "./tree.js";
 const splitTextNode = (node, start, end, mutateMarks) => {
     if (start < 0 || end < start || end > node.text.length) {
         throw new Error("Mark operation range is out of bounds.");
@@ -38,36 +40,180 @@ const replaceTextAtPath = (document, path, replacement) => {
     };
     return replaceNodeAtPath(document, parentPath, nextParent);
 };
-export const applyTransaction = (state, transaction) => {
-    let document = state.document;
-    let selection = state.selection;
-    transaction.operations.forEach((operation) => {
-        if (operation.type === "replaceNode") {
-            document = replaceNodeAtPath(document, operation.path, operation.node);
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const isAncestorPath = (ancestor, descendant) => ancestor.length < descendant.length && ancestor.every((part, index) => descendant[index] === part);
+export const getMoveDestinationAfterRemoval = (from, to) => {
+    const fromParent = from.slice(0, -1);
+    const depth = fromParent.length;
+    const sharesRemovedParent = fromParent.every((part, index) => to[index] === part);
+    if (!sharesRemovedParent || to.length <= depth)
+        return [...to];
+    const destination = [...to];
+    if (from[depth] < destination[depth])
+        destination[depth] -= 1;
+    return destination;
+};
+const nodeAttributes = (node, contentKey) => {
+    const attributes = { ...node };
+    delete attributes[contentKey];
+    return attributes;
+};
+const sameAttributes = (left, right, contentKey) => JSON.stringify(nodeAttributes(left, contentKey)) === JSON.stringify(nodeAttributes(right, contentKey));
+export const applyOperationToState = (document, selection, operation) => {
+    if (operation.type === "insertNode") {
+        return { document: insertNodeAtPath(document, operation.path, operation.node), selection };
+    }
+    if (operation.type === "removeNode") {
+        return { document: removeNodeAtPath(document, operation.path).document, selection };
+    }
+    if (operation.type === "replaceNode") {
+        return { document: replaceNodeAtPath(document, operation.path, operation.node), selection };
+    }
+    if (operation.type === "moveNode") {
+        if (operation.from.length === 0 || operation.to.length === 0) {
+            throw new Error("Move paths cannot target the document root.");
+        }
+        if (samePath(operation.from, operation.to))
+            return { document, selection };
+        if (isAncestorPath(operation.from, operation.to)) {
+            throw new Error("A node cannot be moved into its own descendant.");
+        }
+        const removed = removeNodeAtPath(document, operation.from);
+        const destination = getMoveDestinationAfterRemoval(operation.from, operation.to);
+        return { document: insertNodeAtPath(removed.document, destination, removed.node), selection };
+    }
+    if (operation.type === "splitNode") {
+        if (operation.path.length === 0)
+            throw new Error("The document root cannot be split.");
+        const node = getNodeAtTreePath(document, operation.path);
+        if (!node || typeof node !== "object")
+            throw new Error("Split path does not resolve to a node.");
+        const position = operation.position;
+        if (!Number.isInteger(position) || position < 0)
+            throw new Error("Split position must be a non-negative integer.");
+        let left;
+        let right;
+        if (node.type === "text") {
+            const textNode = node;
+            if (position > textNode.text.length)
+                throw new Error("Text split position is out of bounds.");
+            left = { ...textNode, text: textNode.text.slice(0, position) };
+            right = { ...textNode, text: textNode.text.slice(position) };
         }
-        else if (operation.type === "addMark") {
-            const node = operation.path.reduce((value, index) => {
-                if (!value || typeof value !== "object" || !Array.isArray(value.children))
-                    return undefined;
-                return value.children[index];
-            }, document);
-            if (!node || node.type !== "text")
-                throw new Error("Mark operation path does not resolve to text.");
-            document = replaceTextAtPath(document, operation.path, splitTextNode(node, operation.start, operation.end, (marks) => addMark(marks, operation.mark)));
+        else if (isSmartContainer(node)) {
+            if (position > node.children.length)
+                throw new Error("Container split position is out of bounds.");
+            left = { ...node, children: node.children.slice(0, position) };
+            right = { ...node, children: node.children.slice(position) };
+        }
+        else {
+            throw new Error("Only text nodes and container nodes can be split.");
+        }
+        const replaced = replaceNodeAtPath(document, operation.path, left);
+        const rightPath = [...operation.path.slice(0, -1), operation.path[operation.path.length - 1] + 1];
+        return { document: insertNodeAtPath(replaced, rightPath, right), selection };
+    }
+    if (operation.type === "mergeNode") {
+        if (operation.path.length === 0)
+            throw new Error("The document root cannot be merged.");
+        const rightIndex = operation.path[operation.path.length - 1];
+        if (rightIndex === 0)
+            throw new Error("Merge node has no previous sibling.");
+        const leftPath = [...operation.path.slice(0, -1), rightIndex - 1];
+        const left = getNodeAtTreePath(document, leftPath);
+        const right = getNodeAtTreePath(document, operation.path);
+        if (!left || !right || typeof left !== "object" || typeof right !== "object") {
+            throw new Error("Merge paths must resolve to nodes.");
         }
-        else if (operation.type === "removeMark") {
-            const node = operation.path.reduce((value, index) => {
-                if (!value || typeof value !== "object" || !Array.isArray(value.children))
-                    return undefined;
-                return value.children[index];
-            }, document);
-            if (!node || node.type !== "text")
-                throw new Error("Mark operation path does not resolve to text.");
-            document = replaceTextAtPath(document, operation.path, splitTextNode(node, operation.start, operation.end, (marks) => removeMark(marks, operation.markType)));
+        let merged;
+        if (left.type === "text" && right.type === "text") {
+            const leftText = left;
+            const rightText = right;
+            if (!sameAttributes(left, right, "text")) {
+                throw new Error("Text nodes with different marks cannot be merged.");
+            }
+            merged = { ...leftText, text: leftText.text + rightText.text };
         }
-        else if (operation.type === "setSelection") {
-            selection = operation.selection;
+        else if (isSmartContainer(left) && isSmartContainer(right)) {
+            if (!sameAttributes(left, right, "children")) {
+                throw new Error("Container nodes with different attributes cannot be merged.");
+            }
+            merged = { ...left, children: [...left.children, ...right.children] };
         }
+        else {
+            throw new Error("Merge nodes must have compatible structures.");
+        }
+        const replaced = replaceNodeAtPath(document, leftPath, merged);
+        return { document: removeNodeAtPath(replaced, operation.path).document, selection };
+    }
+    if (operation.type === "setNodeAttrs") {
+        const node = getNodeAtTreePath(document, operation.path);
+        if (!node || typeof node !== "object")
+            throw new Error("Attribute path does not resolve to a node.");
+        if ("type" in operation.attrs || "children" in operation.attrs || "text" in operation.attrs) {
+            throw new Error("setNodeAttrs cannot replace structural node fields.");
+        }
+        const replacement = { ...node };
+        Object.entries(operation.attrs).forEach(([name, value]) => {
+            if (value === undefined)
+                delete replacement[name];
+            else
+                replacement[name] = value;
+        });
+        return { document: replaceNodeAtPath(document, operation.path, replacement), selection };
+    }
+    if (operation.type === "replaceText") {
+        const node = getNodeAtTreePath(document, operation.path);
+        if (!node || node.type !== "text")
+            throw new Error("Text operation path does not resolve to text.");
+        if (!Number.isInteger(operation.start) ||
+            !Number.isInteger(operation.end) ||
+            operation.start < 0 ||
+            operation.end < operation.start ||
+            operation.end > node.text.length) {
+            throw new Error("Text replacement range is out of bounds.");
+        }
+        return {
+            document: replaceNodeAtPath(document, operation.path, {
+                ...node,
+                text: node.text.slice(0, operation.start) + operation.text + node.text.slice(operation.end),
+            }),
+            selection,
+        };
+    }
+    if (operation.type === "addMark") {
+        const node = getNodeAtTreePath(document, operation.path);
+        if (!node || node.type !== "text")
+            throw new Error("Mark operation path does not resolve to text.");
+        return {
+            document: replaceTextAtPath(document, operation.path, splitTextNode(node, operation.start, operation.end, (marks) => addMark(marks, operation.mark))),
+            selection,
+        };
+    }
+    if (operation.type === "removeMark") {
+        const node = getNodeAtTreePath(document, operation.path);
+        if (!node || node.type !== "text")
+            throw new Error("Mark operation path does not resolve to text.");
+        return {
+            document: replaceTextAtPath(document, operation.path, splitTextNode(node, operation.start, operation.end, (marks) => removeMark(marks, operation.markType))),
+            selection,
+        };
+    }
+    return { document, selection: operation.selection };
+};
+export const applyTransaction = (state, transaction) => {
+    let document = state.document;
+    let selection = state.selection;
+    transaction.operations.forEach((operation) => {
+        const documentBefore = document;
+        const next = applyOperationToState(document, selection, operation);
+        document = next.document;
+        selection = operation.type === "setSelection"
+            ? next.selection
+            : mapSelectionThroughOperation(selection, operation, documentBefore);
     });
-    return { document, selection: transaction.selectionAfter || selection };
+    return {
+        document: normalizeSmartDocument(document),
+        selection: transaction.selectionAfter ?? selection,
+    };
 };

package/dist/tree.d.ts

@@ -1,6 +1,12 @@
-import type { Path, SmartDocument } from "./model.js";
+import type { Path, LegacySmartDocument } from "./model.js";
 export interface SmartContainer {
     children: unknown[];
 }
 export declare const isSmartContainer: (value: unknown) => value is SmartContainer;
-export declare const replaceNodeAtPath: <T>(document: SmartDocument, path: Path, replacement: T) => SmartDocument;
+export declare const getNodeAtTreePath: (document: LegacySmartDocument, path: Path) => unknown;
+export declare const replaceNodeAtPath: <T>(document: LegacySmartDocument, path: Path, replacement: T) => LegacySmartDocument;
+export declare const insertNodeAtPath: <T>(document: LegacySmartDocument, path: Path, node: T) => LegacySmartDocument;
+export declare const removeNodeAtPath: (document: LegacySmartDocument, path: Path) => {
+    document: LegacySmartDocument;
+    node: unknown;
+};

package/dist/tree.js

@@ -1,4 +1,26 @@
 export const isSmartContainer = (value) => Boolean(value) && typeof value === "object" && Array.isArray(value.children);
+export const getNodeAtTreePath = (document, path) => {
+    let node = document;
+    for (const index of path) {
+        if (!isSmartContainer(node) || !Number.isInteger(index) || index < 0 || index >= node.children.length) {
+            throw new Error("Path is out of bounds.");
+        }
+        node = node.children[index];
+    }
+    return node;
+};
+const parentAndIndex = (document, path) => {
+    if (path.length === 0)
+        throw new Error("Operation path cannot target the document root.");
+    const index = path[path.length - 1];
+    if (!Number.isInteger(index) || index < 0)
+        throw new Error("Path index must be a non-negative integer.");
+    const parentPath = path.slice(0, -1);
+    const parent = getNodeAtTreePath(document, parentPath);
+    if (!isSmartContainer(parent))
+        throw new Error("Path does not resolve to a document container.");
+    return { parent, parentPath, index };
+};
 export const replaceNodeAtPath = (document, path, replacement) => {
     if (path.length === 0)
         return replacement;
@@ -16,3 +38,25 @@ export const replaceNodeAtPath = (document, path, replacement) => {
     };
     return replace(document, 0);
 };
+export const insertNodeAtPath = (document, path, node) => {
+    const { parent, parentPath, index } = parentAndIndex(document, path);
+    if (index > parent.children.length)
+        throw new Error("Insert path is out of bounds.");
+    return replaceNodeAtPath(document, parentPath, {
+        ...parent,
+        children: [...parent.children.slice(0, index), node, ...parent.children.slice(index)],
+    });
+};
+export const removeNodeAtPath = (document, path) => {
+    const { parent, parentPath, index } = parentAndIndex(document, path);
+    if (index >= parent.children.length)
+        throw new Error("Remove path is out of bounds.");
+    const node = parent.children[index];
+    return {
+        document: replaceNodeAtPath(document, parentPath, {
+            ...parent,
+            children: [...parent.children.slice(0, index), ...parent.children.slice(index + 1)],
+        }),
+        node,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartrte-core",
-  "version": "0.2.0",
+  "version": "1.0.0-beta.1",
   "description": "Framework-agnostic document model and editing primitives for Smart RTE",
   "repository": {
     "type": "git",
@@ -15,6 +15,20 @@
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./foundation": {
+      "types": "./dist/foundation/index.d.ts",
+      "import": "./dist/foundation/index.js"
+    },
+    "./legacy": {
+      "types": "./dist/legacy/index.d.ts",
+      "import": "./dist/legacy/index.js"
+    }
+  },
   "files": [
     "dist",
     "!dist/**/*.test.js",
@@ -22,18 +36,18 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build",
-    "test": "vitest run",
-    "lint": "tsc -p tsconfig.json --noEmit"
-  },
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
   "dependencies": {
+    "@xmldom/xmldom": "^0.9.11",
+    "dompurify": "^3.2.6",
+    "jszip": "^3.10.1",
+    "katex": "^0.18.4",
+    "mammoth": "^1.11.0",
     "parse5": "^7.2.1",
+    "pdfjs-dist": "^5.4.530",
     "rehype-stringify": "^10.0.1",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
@@ -43,5 +57,10 @@
   "devDependencies": {
     "typescript": "^5.6.2",
     "vitest": "^2.1.4"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
   }
-}
+}