smartrte-core 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.2.0
+
+- Add block alignment properties and the `setTextAlignment` command.
+- Add explicit font-size marks.
+- Expand command and compatibility regression coverage.

package/README.md

@@ -0,0 +1,5 @@
+# Smart RTE Core
+
+Framework-agnostic document model, selection, transaction, history, and
+normalization primitives. This package is not yet wired into the published
+React editor; it establishes the compatibility-safe migration boundary.

package/dist/command.d.ts

@@ -0,0 +1,13 @@
+import type { SmartDocument } from "./model.js";
+import type { SmartSelection } from "./selection.js";
+import type { SmartTransaction } from "./transaction.js";
+export interface CommandContext {
+    document: SmartDocument;
+    selection: SmartSelection;
+    now?: () => number;
+}
+export interface SmartCommand<Input = unknown> {
+    id: string;
+    isEnabled(context: CommandContext, input?: Input): boolean;
+    execute(context: CommandContext, input?: Input): SmartTransaction;
+}

package/dist/command.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/alignment.d.ts

@@ -0,0 +1,18 @@
+import { type Path, type SmartDocument, type TextAlignment } from "../model.js";
+import type { SmartSelection } from "../selection.js";
+export interface SetTextAlignmentInput {
+    paths: readonly Path[];
+    alignment: TextAlignment | null;
+}
+export declare const setTextAlignment: (document: SmartDocument, selection: SmartSelection, input: SetTextAlignmentInput) => {
+    document: SmartDocument;
+    transaction: {
+        id: string;
+        source: "user";
+        operations: import("../transaction.js").SmartOperation[];
+        selectionBefore: SmartSelection;
+        selectionAfter: SmartSelection;
+        addToHistory: boolean;
+        timestamp: number;
+    };
+};

package/dist/commands/alignment.js

@@ -0,0 +1,34 @@
+import { getNodeAtPath } from "../model.js";
+import { replaceNodeAtPath } from "../tree.js";
+export const setTextAlignment = (document, selection, input) => {
+    const uniquePaths = Array.from(new Map(input.paths.map((path) => [path.join("."), path])).values());
+    if (uniquePaths.length === 0)
+        throw new Error("At least one aligned block path is required.");
+    let nextDocument = document;
+    const operations = [];
+    uniquePaths.forEach((path) => {
+        const node = getNodeAtPath(nextDocument, path);
+        if (!node || !["paragraph", "heading", "listItem", "blockquote", "codeBlock"].includes(node.type || "")) {
+            throw new Error("Alignment path must resolve to an alignable block.");
+        }
+        const replacement = { ...node };
+        if (!input.alignment || input.alignment === "left")
+            delete replacement.alignment;
+        else
+            replacement.alignment = input.alignment;
+        nextDocument = replaceNodeAtPath(nextDocument, path, replacement);
+        operations.push({ type: "replaceNode", path, node: replacement });
+    });
+    return {
+        document: nextDocument,
+        transaction: {
+            id: "set-text-alignment",
+            source: "user",
+            operations,
+            selectionBefore: selection,
+            selectionAfter: selection,
+            addToHistory: true,
+            timestamp: Date.now(),
+        },
+    };
+};

package/dist/commands/code.d.ts

@@ -0,0 +1,13 @@
+import { type Path, type SmartDocument } from "../model.js";
+import type { SmartSelection } from "../selection.js";
+import type { SmartTransaction } from "../transaction.js";
+export interface ToggleCodeBlocksInput {
+    parentPath: Path;
+    blockIndexes: readonly number[];
+}
+export interface CodeCommandResult {
+    document: SmartDocument;
+    transaction: SmartTransaction;
+}
+/** Converts selected sibling blocks only; neighbours are never inferred or changed. */
+export declare const toggleCodeBlocks: (document: SmartDocument, selection: SmartSelection, input: ToggleCodeBlocksInput) => CodeCommandResult;

package/dist/commands/code.js

@@ -0,0 +1,56 @@
+import { getNodeAtPath, paragraph } from "../model.js";
+import { isSmartContainer, replaceNodeAtPath } from "../tree.js";
+const toCodeBlock = (block) => {
+    if (block.type === "codeBlock")
+        return block;
+    if (block.type === "paragraph" || block.type === "heading") {
+        return {
+            type: "codeBlock",
+            text: block.children.map((child) => child.text).join(""),
+        };
+    }
+    throw new Error(`Cannot convert ${block.type} to a code block.`);
+};
+const toParagraph = (block) => block.type === "codeBlock" ? paragraph(block.text) : block;
+/** Converts selected sibling blocks only; neighbours are never inferred or changed. */
+export const toggleCodeBlocks = (document, selection, input) => {
+    const parent = getNodeAtPath(document, input.parentPath);
+    if (!isSmartContainer(parent))
+        throw new Error("Expected a block container at parentPath.");
+    const indexes = [...new Set(input.blockIndexes)].sort((left, right) => left - right);
+    if (indexes.length === 0)
+        throw new Error("At least one block must be selected.");
+    if (indexes.some((index) => index < 0 || index >= parent.children.length)) {
+        throw new Error("Selected block index is out of bounds.");
+    }
+    const selected = indexes.map((index) => parent.children[index]);
+    const toggleOff = selected.every((block) => block.type === "codeBlock");
+    const selectedIndexes = new Set(indexes);
+    const nextParent = {
+        ...parent,
+        children: parent.children.map((block, index) => {
+            if (!selectedIndexes.has(index))
+                return block;
+            return toggleOff
+                ? toParagraph(block)
+                : toCodeBlock(block);
+        }),
+    };
+    const nextDocument = replaceNodeAtPath(document, input.parentPath, nextParent);
+    const selectionAfter = {
+        type: "node",
+        path: [...input.parentPath, indexes[0]],
+    };
+    return {
+        document: nextDocument,
+        transaction: {
+            id: "toggle-code-blocks",
+            source: "user",
+            operations: [{ type: "replaceNode", path: input.parentPath, node: nextParent }],
+            selectionBefore: selection,
+            selectionAfter,
+            addToHistory: true,
+            timestamp: Date.now(),
+        },
+    };
+};

package/dist/commands/list.d.ts

@@ -0,0 +1,20 @@
+import { type Path, type SmartDocument, type SmartListNode } from "../model.js";
+import type { SmartSelection } from "../selection.js";
+import type { SmartTransaction } from "../transaction.js";
+export type ListStyle = SmartListNode["style"];
+export interface ToggleTableCellListInput {
+    tablePath: Path;
+    row: number;
+    column: number;
+    blockIndexes: readonly number[];
+    style: ListStyle;
+}
+export interface CommandResult {
+    document: SmartDocument;
+    transaction: SmartTransaction;
+}
+/**
+ * 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 declare const toggleTableCellList: (document: SmartDocument, selection: SmartSelection, input: ToggleTableCellListInput) => CommandResult;

package/dist/commands/list.js

@@ -0,0 +1,52 @@
+import { getNodeAtPath, } from "../model.js";
+import { listFromBlocks } from "../table.js";
+import { replaceNodeAtPath } from "../tree.js";
+/**
+ * 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/marks.d.ts

@@ -0,0 +1,17 @@
+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 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>;
+type LinkInput = {
+    href: string;
+    target?: string;
+};
+export declare const applyLink: SmartCommand<LinkInput>;
+export declare const updateLink: SmartCommand<LinkInput>;
+export declare const removeLink: SmartCommand<void>;
+export {};

package/dist/commands/marks.js

@@ -0,0 +1,136 @@
+import { addMark, hasMark, removeMark } from "../marks.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) => {
+    if (context.selection.type !== "text")
+        return null;
+    const { anchor, focus } = context.selection;
+    const parentPath = anchor.path.slice(0, -1);
+    if (!samePath(parentPath, focus.path.slice(0, -1)))
+        return null;
+    const anchorIndex = anchor.path[anchor.path.length - 1];
+    const focusIndex = focus.path[focus.path.length - 1];
+    const forward = anchorIndex < focusIndex || (anchorIndex === focusIndex && anchor.offset <= focus.offset);
+    const startIndex = forward ? anchorIndex : focusIndex;
+    const endIndex = forward ? focusIndex : anchorIndex;
+    const startOffset = forward ? anchor.offset : focus.offset;
+    const endOffset = forward ? focus.offset : anchor.offset;
+    const parent = getNodeAtPath(context.document, parentPath);
+    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"))
+        return null;
+    if (startIndex === endIndex && (startOffset === endOffset || endOffset > nodes[startIndex].text.length))
+        return null;
+    if (startOffset > nodes[startIndex].text.length || endOffset > nodes[endIndex].text.length)
+        return null;
+    return { selection: context.selection, parentPath, startIndex, endIndex, startOffset, endOffset, nodes };
+};
+const replaceRange = (range, mutate) => {
+    const children = [];
+    let selectionStart = 0;
+    let selectionEnd = 0;
+    range.nodes.forEach((node, index) => {
+        if (index < range.startIndex || index > range.endIndex) {
+            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)
+            children.push({ ...node, text: node.text.slice(0, from) });
+        if (index === range.startIndex)
+            selectionStart = children.length;
+        const selected = node.text.slice(from, to);
+        if (selected)
+            children.push({ type: "text", text: selected, marks: mutate(node.marks) });
+        if (index === range.endIndex)
+            selectionEnd = children.length - 1;
+        if (to < node.text.length)
+            children.push({ ...node, text: node.text.slice(to) });
+    });
+    return { children, start: selectionStart, end: selectionEnd };
+};
+const hasLink = (marks) => marks?.some((mark) => mark.type === "link") || false;
+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 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 },
+    };
+    return {
+        id,
+        source: "user",
+        operations: [{ type: "replaceNode", path: range.parentPath, node: { ...parent, children: result.children } }],
+        selectionBefore: range.selection,
+        selectionAfter,
+        addToHistory: true,
+        timestamp: context.now?.() ?? Date.now(),
+    };
+};
+const createMarkCommand = (id, nextMark, toggle) => ({
+    id,
+    isEnabled: (context) => Boolean(getTextRange(context)),
+    execute: (context, input) => {
+        const range = getTextRange(context);
+        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 remove = toggle && selected.every((node) => hasMark(node.marks, mark.type));
+        return createMarkTransaction(id, context, input, (marks) => remove ? removeMark(marks, mark.type) : addMark(marks, mark));
+    },
+});
+const toggle = (id, type) => createMarkCommand(id, () => ({ type }), true);
+export const toggleBold = toggle("toggle-bold", "bold");
+export const toggleItalic = toggle("toggle-italic", "italic");
+export const toggleUnderline = toggle("toggle-underline", "underline");
+export const toggleSuperscript = toggle("toggle-superscript", "superscript");
+export const toggleSubscript = toggle("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 applyLink = {
+    id: "apply-link",
+    isEnabled: (context, input) => Boolean(getTextRange(context) && input && sanitizeLinkAttrs(input)),
+    execute: (context, input) => {
+        const safe = sanitizeLinkAttrs(input || {});
+        if (!safe)
+            throw new Error("apply-link requires a safe href.");
+        return createMarkTransaction("apply-link", context, input, (marks) => addMark(marks, { type: "link", ...safe }));
+    },
+};
+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)));
+    },
+    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))) {
+            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 }));
+    },
+};
+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)));
+    },
+    execute: (context) => {
+        if (!removeLink.isEnabled(context))
+            throw new Error("remove-link requires selected linked text.");
+        return createMarkTransaction("remove-link", context, undefined, (marks) => removeMark(marks, "link"));
+    },
+};

package/dist/html/compatibility.d.ts

@@ -0,0 +1,21 @@
+type HtmlAttribute = {
+    name: string;
+    value: string;
+};
+type HtmlNode = {
+    nodeName: string;
+    tagName?: string;
+    attrs?: HtmlAttribute[];
+    childNodes?: HtmlNode[];
+    parentNode?: HtmlNode;
+    namespaceURI?: string;
+};
+export interface HtmlCompatibilityDocument {
+    fragment: HtmlNode;
+}
+/** Parses legacy HTML into a canonical, editor-UI-free compatibility document. */
+export declare const parseCompatibilityHtml: (html: string) => HtmlCompatibilityDocument;
+/** Serializes canonical compatibility HTML for persisted value/onChange output. */
+export declare const serializeCompatibilityHtml: (document: HtmlCompatibilityDocument) => string;
+export declare const normalizeCompatibilityHtml: (html: string) => string;
+export {};

package/dist/html/compatibility.js

@@ -0,0 +1,68 @@
+import { parseFragment, serialize } from "parse5";
+const BLOCK_TAGS = new Set([
+    "p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li",
+    "blockquote", "pre", "table", "div",
+]);
+const attrsOf = (node) => node.attrs || [];
+const hasAttr = (node, name, value) => attrsOf(node).some((attr) => attr.name === name && (value == null || attr.value === value));
+const isTag = (node, tagName) => node.tagName === tagName;
+const isWhitespaceText = (node) => node.nodeName === "#text" && !node.value?.trim();
+const createParagraph = (children) => ({
+    nodeName: "p",
+    tagName: "p",
+    namespaceURI: "http://www.w3.org/1999/xhtml",
+    attrs: [],
+    childNodes: children,
+});
+const normalizeTableCell = (cell) => {
+    const children = cell.childNodes || [];
+    if (children.some((child) => child.tagName && BLOCK_TAGS.has(child.tagName)))
+        return;
+    const lines = [[]];
+    children.forEach((child) => {
+        if (isTag(child, "br")) {
+            lines.push([]);
+        }
+        else {
+            lines[lines.length - 1].push(child);
+        }
+    });
+    const nonEmptyLines = lines.filter((line) => line.some((child) => !isWhitespaceText(child)));
+    if (nonEmptyLines.length === 0)
+        return;
+    cell.childNodes = nonEmptyLines.map(createParagraph);
+};
+const normalizeNode = (node) => {
+    node.attrs = attrsOf(node).filter((attr) => {
+        if (attr.name === "data-table-wrapper")
+            return false;
+        if (attr.name === "data-row-index" || attr.name === "data-col-index")
+            return false;
+        return !attr.name.startsWith("data-srte-");
+    });
+    if (!node.childNodes)
+        return;
+    const normalizedChildren = [];
+    node.childNodes.forEach((child) => {
+        const isTableWrapper = hasAttr(child, "data-table-wrapper", "true");
+        normalizeNode(child);
+        if (isTableWrapper) {
+            (child.childNodes || []).forEach((nested) => normalizedChildren.push(nested));
+        }
+        else {
+            normalizedChildren.push(child);
+        }
+    });
+    node.childNodes = normalizedChildren;
+    if (isTag(node, "td") || isTag(node, "th"))
+        normalizeTableCell(node);
+};
+/** Parses legacy HTML into a canonical, editor-UI-free compatibility document. */
+export const parseCompatibilityHtml = (html) => {
+    const fragment = parseFragment(html);
+    normalizeNode(fragment);
+    return { fragment };
+};
+/** Serializes canonical compatibility HTML for persisted value/onChange output. */
+export const serializeCompatibilityHtml = (document) => serialize(document.fragment);
+export const normalizeCompatibilityHtml = (html) => serializeCompatibilityHtml(parseCompatibilityHtml(html));

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./model.js";
+export * from "./command.js";
+export * from "./marks.js";
+export * from "./selection.js";
+export * from "./table.js";
+export * from "./transaction.js";
+export * from "./tree.js";
+export * from "./commands/list.js";
+export * from "./commands/code.js";
+export * from "./commands/marks.js";
+export * from "./commands/alignment.js";
+export * from "./html/compatibility.js";
+export * from "./markdown/compatibility.js";
+export * from "./security/urlPolicy.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./model.js";
+export * from "./command.js";
+export * from "./marks.js";
+export * from "./selection.js";
+export * from "./table.js";
+export * from "./transaction.js";
+export * from "./tree.js";
+export * from "./commands/list.js";
+export * from "./commands/code.js";
+export * from "./commands/marks.js";
+export * from "./commands/alignment.js";
+export * from "./html/compatibility.js";
+export * from "./markdown/compatibility.js";
+export * from "./security/urlPolicy.js";

package/dist/markdown/compatibility.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts CommonMark/GFM input to canonical Smart RTE HTML.
+ *
+ * This is intentionally separate from HTML import. Markdown provides list
+ * indentation and table syntax that no HTML repair pass can recover once lost.
+ */
+export declare const markdownToCompatibilityHtml: (markdown: string) => string;

package/dist/markdown/compatibility.js

@@ -0,0 +1,21 @@
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { normalizeCompatibilityHtml } from "../html/compatibility.js";
+/**
+ * Converts CommonMark/GFM input to canonical Smart RTE HTML.
+ *
+ * This is intentionally separate from HTML import. Markdown provides list
+ * indentation and table syntax that no HTML repair pass can recover once lost.
+ */
+export const markdownToCompatibilityHtml = (markdown) => {
+    const html = String(unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkRehype)
+        .use(rehypeStringify)
+        .processSync(markdown));
+    return normalizeCompatibilityHtml(html);
+};

package/dist/marks.d.ts

@@ -0,0 +1,7 @@
+import type { SmartMark } from "./model.js";
+export type InlineMarkType = Extract<SmartMark, {
+    type: string;
+}>['type'];
+export declare const hasMark: (marks: readonly SmartMark[] | undefined, type: InlineMarkType) => boolean;
+export declare const addMark: (marks: readonly SmartMark[] | undefined, mark: SmartMark) => SmartMark[];
+export declare const removeMark: (marks: readonly SmartMark[] | undefined, type: InlineMarkType) => SmartMark[] | undefined;

package/dist/marks.js

@@ -0,0 +1,9 @@
+export const hasMark = (marks, type) => Boolean(marks?.some((mark) => mark.type === type));
+export const addMark = (marks, mark) => [
+    ...(marks || []).filter((existing) => existing.type !== mark.type),
+    mark,
+];
+export const removeMark = (marks, type) => {
+    const next = (marks || []).filter((mark) => mark.type !== type);
+    return next.length > 0 ? next : undefined;
+};

package/dist/model.d.ts

@@ -0,0 +1,88 @@
+export type Path = readonly number[];
+export type TextAlignment = "left" | "center" | "right" | "justify";
+export type SmartMark = {
+    type: "bold";
+} | {
+    type: "italic";
+} | {
+    type: "underline";
+} | {
+    type: "strike";
+} | {
+    type: "superscript";
+} | {
+    type: "subscript";
+} | {
+    type: "code";
+} | {
+    type: "textColor";
+    value: string;
+} | {
+    type: "backgroundColor";
+    value: string;
+} | {
+    type: "fontSize";
+    valuePx: number;
+} | {
+    type: "link";
+    href: string;
+    target?: string;
+};
+export interface SmartTextNode {
+    type: "text";
+    text: string;
+    marks?: SmartMark[];
+}
+export interface SmartParagraphNode {
+    type: "paragraph";
+    alignment?: TextAlignment;
+    children: SmartTextNode[];
+}
+export interface SmartHeadingNode {
+    type: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    alignment?: TextAlignment;
+    children: SmartTextNode[];
+}
+export interface SmartListItemNode {
+    type: "listItem";
+    alignment?: TextAlignment;
+    children: SmartBlockNode[];
+}
+export interface SmartListNode {
+    type: "list";
+    style: "disc" | "circle" | "square" | "decimal" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+    children: SmartListItemNode[];
+}
+export interface SmartBlockquoteNode {
+    type: "blockquote";
+    alignment?: TextAlignment;
+    children: SmartBlockNode[];
+}
+export interface SmartCodeBlockNode {
+    type: "codeBlock";
+    alignment?: TextAlignment;
+    text: string;
+    language?: string;
+}
+export interface SmartTableCellNode {
+    type: "tableCell" | "tableHeaderCell";
+    colspan?: number;
+    rowspan?: number;
+    children: SmartBlockNode[];
+}
+export interface SmartTableRowNode {
+    type: "tableRow";
+    children: SmartTableCellNode[];
+}
+export interface SmartTableNode {
+    type: "table";
+    children: SmartTableRowNode[];
+}
+export type SmartBlockNode = SmartParagraphNode | SmartHeadingNode | SmartListNode | SmartBlockquoteNode | SmartCodeBlockNode | SmartTableNode;
+export interface SmartDocument {
+    type: "doc";
+    children: SmartBlockNode[];
+}
+export declare const paragraph: (text?: string) => SmartParagraphNode;
+export declare const getNodeAtPath: (document: SmartDocument, path: Path) => unknown;

package/dist/model.js

@@ -0,0 +1,14 @@
+export const paragraph = (text = "") => ({
+    type: "paragraph",
+    children: [{ type: "text", text }],
+});
+export const getNodeAtPath = (document, path) => {
+    let node = document;
+    for (const index of path) {
+        if (!node || typeof node !== "object" || !Array.isArray(node.children)) {
+            return undefined;
+        }
+        node = node.children[index];
+    }
+    return node;
+};

package/dist/security/urlPolicy.d.ts

@@ -0,0 +1,17 @@
+export interface SafeLinkAttrs {
+    href: string;
+    target?: string;
+}
+export type NormalizedLinkKind = "url" | "email" | "phone" | "anchor" | "invalid";
+export interface NormalizedLinkResult {
+    kind: NormalizedLinkKind;
+    href: string | null;
+    input: string;
+}
+export declare const normalizeLinkInput: (input: string | undefined | null) => NormalizedLinkResult;
+export declare const sanitizeLinkHref: (href: string | undefined | null) => string | null;
+export declare const sanitizeLinkTarget: (target: string | undefined) => string | undefined;
+export declare const sanitizeLinkAttrs: (input: {
+    href?: string;
+    target?: string;
+}) => SafeLinkAttrs | null;

package/dist/security/urlPolicy.js

@@ -0,0 +1,69 @@
+const allowedProtocols = new Set(["http:", "https:", "mailto:", "tel:"]);
+const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const bareDomainPattern = /^(?:www\.)?[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+(?:[/?#][^\s]*)?$/;
+const phonePattern = /^\+?[\d\s().-]{7,}$/;
+const normalizePhone = (value) => {
+    const hasLeadingPlus = value.trim().startsWith("+");
+    const digits = value.replace(/[^\d]/g, "");
+    if (digits.length < 7)
+        return null;
+    return `${hasLeadingPlus ? "+" : ""}${digits}`;
+};
+const normalizeMailto = (value) => {
+    const email = value.slice("mailto:".length).trim();
+    return emailPattern.test(email) ? `mailto:${email}` : null;
+};
+const normalizeTel = (value) => {
+    const phone = normalizePhone(value.slice("tel:".length));
+    return phone ? `tel:${phone}` : null;
+};
+export const normalizeLinkInput = (input) => {
+    const trimmed = input?.trim() || "";
+    if (!trimmed)
+        return { kind: "invalid", href: null, input: "" };
+    if (/^mailto:/i.test(trimmed)) {
+        const href = normalizeMailto(trimmed);
+        return { kind: href ? "email" : "invalid", href, input: trimmed };
+    }
+    if (/^tel:/i.test(trimmed)) {
+        const href = normalizeTel(trimmed);
+        return { kind: href ? "phone" : "invalid", href, input: trimmed };
+    }
+    if (emailPattern.test(trimmed)) {
+        return { kind: "email", href: `mailto:${trimmed}`, input: trimmed };
+    }
+    const phone = normalizePhone(trimmed);
+    if (phone && (trimmed.startsWith("+") || phonePattern.test(trimmed))) {
+        return { kind: "phone", href: `tel:${phone}`, input: trimmed };
+    }
+    if (/^#[A-Za-z][\w:.-]*$/.test(trimmed)) {
+        return { kind: "anchor", href: trimmed, input: trimmed };
+    }
+    if (bareDomainPattern.test(trimmed)) {
+        return { kind: "url", href: `https://${trimmed}`, input: trimmed };
+    }
+    try {
+        const parsed = new URL(trimmed);
+        return {
+            kind: allowedProtocols.has(parsed.protocol) ? "url" : "invalid",
+            href: allowedProtocols.has(parsed.protocol) ? trimmed : null,
+            input: trimmed,
+        };
+    }
+    catch {
+        return { kind: "invalid", href: null, input: trimmed };
+    }
+};
+export const sanitizeLinkHref = (href) => {
+    return normalizeLinkInput(href).href;
+};
+export const sanitizeLinkTarget = (target) => {
+    const trimmed = target?.trim();
+    return trimmed || undefined;
+};
+export const sanitizeLinkAttrs = (input) => {
+    const href = sanitizeLinkHref(input.href);
+    if (!href)
+        return null;
+    return { href, target: sanitizeLinkTarget(input.target) };
+};

package/dist/selection.d.ts

@@ -0,0 +1,30 @@
+import type { Path } from "./model.js";
+export interface SmartPoint {
+    path: Path;
+    offset: number;
+}
+export interface SmartTextSelection {
+    type: "text";
+    anchor: SmartPoint;
+    focus: SmartPoint;
+}
+export interface SmartNodeSelection {
+    type: "node";
+    path: Path;
+}
+export interface SmartCellSelection {
+    type: "cell";
+    tablePath: Path;
+    start: {
+        row: number;
+        column: number;
+    };
+    end: {
+        row: number;
+        column: number;
+    };
+}
+export interface SmartAllSelection {
+    type: "all";
+}
+export type SmartSelection = SmartTextSelection | SmartNodeSelection | SmartCellSelection | SmartAllSelection;

package/dist/selection.js

@@ -0,0 +1 @@
+export {};

package/dist/table.d.ts

@@ -0,0 +1,11 @@
+import { type SmartBlockNode, 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") => {
+    type: "list";
+    style: "disc" | "circle" | "square" | "decimal" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+    children: {
+        type: "listItem";
+        children: SmartBlockNode[];
+    }[];
+};

package/dist/table.js

@@ -0,0 +1,17 @@
+import { paragraph } from "./model.js";
+/** Ensures table cells have blocks even when imported HTML supplied raw lines. */
+export const normalizeTableCell = (cell, rawLines = []) => {
+    if (cell.children.length > 0)
+        return cell;
+    return {
+        ...cell,
+        children: rawLines.length > 0
+            ? rawLines.map((line) => paragraph(line))
+            : [paragraph()],
+    };
+};
+export const listFromBlocks = (blocks, style = "disc") => ({
+    type: "list",
+    style,
+    children: blocks.map((block) => ({ type: "listItem", children: [block] })),
+});

package/dist/transaction.d.ts

@@ -0,0 +1,48 @@
+import type { SmartDocument, Path, SmartMark } from "./model.js";
+import type { SmartSelection } from "./selection.js";
+import { type InlineMarkType } from "./marks.js";
+export type SmartOperation = {
+    type: "insertNode";
+    path: Path;
+    node: unknown;
+} | {
+    type: "removeNode";
+    path: Path;
+} | {
+    type: "replaceNode";
+    path: Path;
+    node: unknown;
+} | {
+    type: "setNodeAttrs";
+    path: Path;
+    attrs: Record<string, unknown>;
+} | {
+    type: "addMark";
+    path: Path;
+    start: number;
+    end: number;
+    mark: SmartMark;
+} | {
+    type: "removeMark";
+    path: Path;
+    start: number;
+    end: number;
+    markType: InlineMarkType;
+} | {
+    type: "setSelection";
+    selection: SmartSelection;
+};
+export interface SmartTransaction {
+    id: string;
+    source: "user" | "paste" | "api" | "history" | "normalizer";
+    operations: SmartOperation[];
+    selectionBefore: SmartSelection;
+    selectionAfter: SmartSelection;
+    addToHistory: boolean;
+    timestamp: number;
+}
+export interface SmartEditorState {
+    document: SmartDocument;
+    selection: SmartSelection;
+}
+export declare const applyTransaction: (state: SmartEditorState, transaction: SmartTransaction) => SmartEditorState;

package/dist/transaction.js

@@ -0,0 +1,73 @@
+import { addMark, removeMark } from "./marks.js";
+import { 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.");
+    }
+    const result = [];
+    if (start > 0)
+        result.push({ ...node, text: node.text.slice(0, start) });
+    const selectedText = node.text.slice(start, end);
+    if (selectedText)
+        result.push({ type: "text", text: selectedText, marks: mutateMarks(node.marks) });
+    if (end < node.text.length)
+        result.push({ ...node, text: node.text.slice(end) });
+    return result;
+};
+const replaceTextAtPath = (document, path, replacement) => {
+    if (path.length === 0)
+        throw new Error("A text node path cannot be empty.");
+    const parentPath = path.slice(0, -1);
+    const textIndex = path[path.length - 1];
+    const parent = parentPath.reduce((node, index) => {
+        if (!node || typeof node !== "object" || !Array.isArray(node.children)) {
+            return undefined;
+        }
+        return node.children[index];
+    }, document);
+    if (!parent || typeof parent !== "object" || !Array.isArray(parent.children)) {
+        throw new Error("Mark operation parent is not a text container.");
+    }
+    const children = parent.children;
+    const target = children[textIndex];
+    if (!target || target.type !== "text")
+        throw new Error("Mark operation path does not resolve to text.");
+    const nextParent = {
+        ...parent,
+        children: [...children.slice(0, textIndex), ...replacement, ...children.slice(textIndex + 1)],
+    };
+    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);
+        }
+        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 (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)));
+        }
+        else if (operation.type === "setSelection") {
+            selection = operation.selection;
+        }
+    });
+    return { document, selection: transaction.selectionAfter || selection };
+};

package/dist/tree.d.ts

@@ -0,0 +1,6 @@
+import type { Path, SmartDocument } 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;

package/dist/tree.js

@@ -0,0 +1,18 @@
+export const isSmartContainer = (value) => Boolean(value) && typeof value === "object" && Array.isArray(value.children);
+export const replaceNodeAtPath = (document, path, replacement) => {
+    if (path.length === 0)
+        return replacement;
+    const replace = (node, depth) => {
+        if (!isSmartContainer(node))
+            throw new Error("Path does not resolve to a document container.");
+        const index = path[depth];
+        if (index < 0 || index >= node.children.length)
+            throw new Error("Path is out of bounds.");
+        const children = [...node.children];
+        children[index] = depth === path.length - 1
+            ? replacement
+            : replace(children[index], depth + 1);
+        return { ...node, children };
+    };
+    return replace(document, 0);
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "smartrte-core",
+  "version": "0.2.0",
+  "description": "Framework-agnostic document model and editing primitives for Smart RTE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ayush1852017/smart-rte.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/ayush1852017/smart-rte#readme",
+  "bugs": {
+    "url": "https://github.com/ayush1852017/smart-rte/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "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": {
+    "parse5": "^7.2.1",
+    "rehype-stringify": "^10.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.1",
+    "unified": "^11.0.5"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.2",
+    "vitest": "^2.1.4"
+  }
+}