@bayonai/rich-text-editor 0.1.2 → 1.0.0

package/dist/core/richText.js

@@ -0,0 +1,566 @@
+const allowedInlineTags = new Set(["a", "br", "code", "em", "strong"]);
+const textBlockTypes = new Set([
+    "paragraph",
+    "message",
+    "heading",
+    "quote",
+    "bullet",
+    "ordered",
+    "checkbox",
+    "toggle",
+]);
+const richTextClipboardPrefix = "bounded-rich-text-blocks-v1:";
+const toolBlockStatuses = new Set([
+    "pending",
+    "success",
+    "error",
+]);
+const invalidToolData = Symbol("invalidToolData");
+const maxToolDataDepth = 8;
+export function createEmptyRichTextBlocks() {
+    return [{ id: createRichTextBlockId(), type: "paragraph", markdown: "" }];
+}
+export function createRichTextBlockId() {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return crypto.randomUUID();
+    }
+    return `block-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+/**
+ * Sanitizes an array of RichTextBlock objects by:
+ * - Filtering out invalid blocks
+ * - Ensuring each block has a unique ID
+ * - Returning an empty array if no valid blocks remain
+ */
+export function sanitizeRichTextBlocks(value) {
+    return sanitizeRichTextBlocksWithSeen(value, new Set());
+}
+function sanitizeRichTextBlocksWithSeen(value, seenBlockIds) {
+    const blocks = Array.isArray(value) ? value : [];
+    const sanitized = blocks
+        .flatMap((block) => sanitizeRichTextBlock(block, seenBlockIds))
+        .map((block) => {
+        if (!seenBlockIds.has(block.id)) {
+            seenBlockIds.add(block.id);
+            return block;
+        }
+        const blockWithUniqueId = {
+            ...block,
+            id: createUniqueRichTextBlockId(seenBlockIds),
+        };
+        seenBlockIds.add(blockWithUniqueId.id);
+        return blockWithUniqueId;
+    });
+    return sanitized.length > 0 ? sanitized : createEmptyRichTextBlocks();
+}
+export function isRichTextBlocksEmpty(blocks) {
+    return sanitizeRichTextBlocks(blocks).every((block) => {
+        if (block.type === "divider") {
+            return false;
+        }
+        if (block.type === "checkbox") {
+            return markdownToPlainText(block.markdown).trim() === "";
+        }
+        if (block.type === "image") {
+            return !block.url && typeof block.uploadProgress !== "number";
+        }
+        if (block.type === "tool") {
+            return false;
+        }
+        const text = block.type === "code" ? block.text : block.markdown;
+        return markdownToPlainText(text).trim() === "";
+    });
+}
+export function richTextBlocksToPlainText(blocks) {
+    return sanitizeRichTextBlocks(blocks)
+        .map((block) => {
+        if (block.type === "divider") {
+            return "";
+        }
+        if (block.type === "checkbox") {
+            return [
+                markdownToPlainText(block.markdown),
+                ...richTextBlocksToPlainText(block.children ?? [])
+                    .split(" ")
+                    .filter(Boolean),
+            ]
+                .filter(Boolean)
+                .join(" ");
+        }
+        if (block.type === "image") {
+            return block.alt ?? "";
+        }
+        if (block.type === "tool") {
+            return [
+                `[Tool: ${block.title || block.toolType} ${block.status}]`,
+                block.markdown ? markdownToPlainText(block.markdown) : "",
+            ]
+                .filter(Boolean)
+                .join(" ");
+        }
+        if (block.type === "bullet" ||
+            block.type === "ordered" ||
+            block.type === "toggle") {
+            return [
+                markdownToPlainText(block.markdown),
+                richTextBlocksToPlainText(block.children ?? []),
+            ]
+                .filter(Boolean)
+                .join(" ");
+        }
+        return block.type === "code"
+            ? block.text
+            : markdownToPlainText(block.markdown);
+    })
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function encodeRichTextBlocksForClipboard(blocks) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const encoded = encodeURIComponent(JSON.stringify(sanitizedBlocks));
+    const plainText = richTextBlocksToPlainText(sanitizedBlocks);
+    return `${richTextClipboardPrefix}${encoded}${plainText ? `\n${plainText}` : ""}`;
+}
+export function decodeRichTextBlocksFromClipboardText(value) {
+    const [firstLine] = value.split(/\r?\n/, 1);
+    if (!firstLine?.startsWith(richTextClipboardPrefix)) {
+        return null;
+    }
+    try {
+        const decoded = decodeURIComponent(firstLine.slice(richTextClipboardPrefix.length));
+        const parsed = JSON.parse(decoded);
+        return Array.isArray(parsed) ? sanitizeRichTextBlocks(parsed) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function editorHtmlToMarkdown(html) {
+    const sanitized = normalizeTypography(decodeHtmlText(sanitizeRichTextHtml(html)
+        .replace(/<br>/g, "  \n")
+        .replace(/<strong>([\s\S]*?)<\/strong>/g, (_, value) => {
+        return `**${decodeHtmlText(stripTags(value))}**`;
+    })
+        .replace(/<em>([\s\S]*?)<\/em>/g, (_, value) => {
+        return `_${decodeHtmlText(stripTags(value))}_`;
+    })
+        .replace(/<code>([\s\S]*?)<\/code>/g, (_, value) => {
+        return `\`${decodeHtmlText(stripTags(value)).replace(/`/g, "\\`")}\``;
+    })
+        .replace(/<a href="([^"]*)">([\s\S]*?)<\/a>/g, (_, href, value) => {
+        return `[${decodeHtmlText(stripTags(value))}](${decodeHtmlText(href)})`;
+    })
+        .replace(/<a>([\s\S]*?)<\/a>/g, (_, value) => {
+        return decodeHtmlText(stripTags(value));
+    })
+        .replace(/<[^>]+>/g, ""))).replace(/\u00a0/g, " ");
+    return stripWhitespaceOnlyMarkdown(sanitized);
+}
+export function markdownToEditorHtml(markdown) {
+    const tokens = [];
+    let html = escapeHtmlText(normalizeTypography(markdown));
+    html = html.replace(/`([^`\n]+)`/g, (_, value) => {
+        const token = pushToken(tokens, `<code>${value}</code>`);
+        return token;
+    });
+    html = html.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_, label, href) => {
+        const safeHref = getSafeUrl(decodeHtmlText(href));
+        return safeHref ? `<a href="${safeHref}">${label}</a>` : label;
+    });
+    html = html
+        .replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>")
+        .replace(/_([^_\n]+)_/g, "<em>$1</em>")
+        .replace(/ {2}\n/g, "<br>")
+        .replace(/\n/g, "<br>");
+    tokens.forEach((value, index) => {
+        html = html.replace(tokenPlaceholder(index), value);
+    });
+    return html;
+}
+export function sanitizeRichTextHtml(html) {
+    return html
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<b(\s[^>]*)?>/gi, "<strong>")
+        .replace(/<\/b>/gi, "</strong>")
+        .replace(/<i(\s[^>]*)?>/gi, "<em>")
+        .replace(/<\/i>/gi, "</em>")
+        .replace(/<\/?([a-z0-9]+)([^>]*)>/gi, (match, rawTag, rawAttrs) => {
+        const tag = String(rawTag).toLowerCase();
+        const closing = match.startsWith("</");
+        if (!allowedInlineTags.has(tag)) {
+            return "";
+        }
+        if (closing) {
+            return tag === "br" ? "" : `</${tag}>`;
+        }
+        if (tag === "a") {
+            const href = getSafeAttribute(rawAttrs, "href");
+            return href ? `<a href="${href}">` : "<a>";
+        }
+        return tag === "br" ? "<br>" : `<${tag}>`;
+    });
+}
+function sanitizeRichTextBlock(block, seenBlockIds) {
+    if (!isRecord(block)) {
+        return [];
+    }
+    const id = readBlockId(block);
+    const type = block.type;
+    if (type === "code") {
+        return [{ id, type, text: String(block.text ?? "") }];
+    }
+    if (type === "divider") {
+        return [{ id, type }];
+    }
+    if (type === "image") {
+        const safeUrl = typeof block.url === "string" && getSafeUrl(block.url)
+            ? getSafeUrl(block.url)
+            : "";
+        const uploadProgress = typeof block.uploadProgress === "number" &&
+            Number.isFinite(block.uploadProgress)
+            ? clamp(Math.round(block.uploadProgress), 0, 100)
+            : null;
+        const displaySize = readImageDisplaySize(block.displaySize);
+        const customWidth = readImageCustomWidth(block.customWidth);
+        if (!safeUrl && uploadProgress === null) {
+            return [];
+        }
+        return [
+            {
+                id,
+                type,
+                alignment: readImageAlignment(block.alignment),
+                ...(displaySize ? { displaySize } : {}),
+                ...(displaySize === "custom" && customWidth
+                    ? { customWidth }
+                    : {}),
+                ...(safeUrl ? { url: safeUrl } : {}),
+                ...(typeof block.alt === "string" && block.alt.trim()
+                    ? { alt: markdownToPlainText(editorHtmlToMarkdown(block.alt)) }
+                    : {}),
+                ...(uploadProgress !== null ? { uploadProgress } : {}),
+            },
+        ];
+    }
+    if (type === "tool") {
+        return [sanitizeToolBlock(block, id)];
+    }
+    if (typeof type === "string" && textBlockTypes.has(type)) {
+        const markdown = typeof block.markdown === "string"
+            ? block.markdown
+            : typeof block.text === "string"
+                ? block.text
+                : typeof block.html === "string"
+                    ? editorHtmlToMarkdown(block.html)
+                    : "";
+        if (type === "bullet" || type === "ordered") {
+            return [
+                withSanitizedChildren({
+                    id,
+                    type: type,
+                    markdown: sanitizeMarkdown(markdown),
+                }, block, seenBlockIds),
+            ];
+        }
+        if (type === "checkbox") {
+            return [
+                withSanitizedChildren({
+                    id,
+                    type,
+                    checked: Boolean(block.checked),
+                    markdown: sanitizeMarkdown(markdown),
+                }, block, seenBlockIds),
+            ];
+        }
+        if (type === "toggle") {
+            const children = sanitizeRichTextChildBlocksWithSeen(block.children, seenBlockIds);
+            return [
+                {
+                    id,
+                    type,
+                    collapsed: Boolean(block.collapsed),
+                    markdown: sanitizeMarkdown(markdown),
+                    children,
+                },
+            ];
+        }
+        return [
+            {
+                id,
+                type: type,
+                markdown: sanitizeMarkdown(markdown),
+            },
+        ];
+    }
+    return [];
+}
+function sanitizeToolBlock(block, id) {
+    const toolType = readToolType(block.toolType, id);
+    const status = readToolStatus(block.status, id);
+    const title = typeof block.title === "string" && block.title.trim()
+        ? markdownToPlainText(editorHtmlToMarkdown(block.title))
+        : "";
+    const markdown = typeof block.markdown === "string"
+        ? sanitizeMarkdown(block.markdown)
+        : typeof block.text === "string"
+            ? sanitizeMarkdown(block.text)
+            : typeof block.html === "string"
+                ? sanitizeMarkdown(editorHtmlToMarkdown(block.html))
+                : "";
+    const dataResult = "data" in block ? sanitizeToolData(block.data, id) : null;
+    return {
+        id,
+        type: "tool",
+        toolType,
+        status,
+        ...(title ? { title } : {}),
+        ...(markdown ? { markdown } : {}),
+        ...(dataResult?.value !== undefined ? { data: dataResult.value } : {}),
+    };
+}
+function readToolType(value, blockId) {
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    console.warn("[RichText] Tool block has an invalid toolType.", { blockId });
+    return "unknown";
+}
+function readToolStatus(value, blockId) {
+    if (typeof value === "string" &&
+        toolBlockStatuses.has(value)) {
+        return value;
+    }
+    console.warn("[RichText] Tool block has an invalid status.", {
+        blockId,
+        status: value,
+    });
+    return "success";
+}
+function sanitizeToolData(value, blockId) {
+    const result = sanitizeToolDataValue(value, {
+        depth: 0,
+        seen: new WeakSet(),
+    });
+    if (result.changed) {
+        console.warn("[RichText] Tool block data contained unsupported values.", {
+            blockId,
+        });
+    }
+    return result.value === invalidToolData
+        ? null
+        : { changed: result.changed, value: result.value };
+}
+function sanitizeToolDataValue(value, context) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "string") {
+        return { changed: false, value };
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value)
+            ? { changed: false, value }
+            : { changed: true, value: invalidToolData };
+    }
+    if (typeof value !== "object" || value === undefined) {
+        return { changed: true, value: invalidToolData };
+    }
+    if (context.depth >= maxToolDataDepth) {
+        return { changed: true, value: invalidToolData };
+    }
+    if (context.seen.has(value)) {
+        return { changed: true, value: invalidToolData };
+    }
+    context.seen.add(value);
+    if (Array.isArray(value)) {
+        let changed = false;
+        const sanitizedArray = [];
+        value.forEach((item) => {
+            const result = sanitizeToolDataValue(item, {
+                depth: context.depth + 1,
+                seen: context.seen,
+            });
+            if (result.value === invalidToolData) {
+                changed = true;
+                return;
+            }
+            changed = changed || result.changed;
+            sanitizedArray.push(result.value);
+        });
+        context.seen.delete(value);
+        return { changed, value: sanitizedArray };
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        context.seen.delete(value);
+        return { changed: true, value: invalidToolData };
+    }
+    let changed = false;
+    const sanitizedRecord = {};
+    Object.entries(value).forEach(([key, item]) => {
+        const result = sanitizeToolDataValue(item, {
+            depth: context.depth + 1,
+            seen: context.seen,
+        });
+        if (result.value === invalidToolData) {
+            changed = true;
+            return;
+        }
+        changed = changed || result.changed;
+        sanitizedRecord[key] = result.value;
+    });
+    context.seen.delete(value);
+    return { changed, value: sanitizedRecord };
+}
+function withSanitizedChildren(sanitizedBlock, rawBlock, seenBlockIds) {
+    const children = sanitizeRichTextChildBlocksWithSeen(rawBlock.children, seenBlockIds);
+    if (children.length === 0) {
+        return sanitizedBlock;
+    }
+    return { ...sanitizedBlock, children };
+}
+function sanitizeRichTextChildBlocksWithSeen(value, seenBlockIds) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .flatMap((block) => sanitizeRichTextBlock(block, seenBlockIds))
+        .map((block) => {
+        if (!seenBlockIds.has(block.id)) {
+            seenBlockIds.add(block.id);
+            return block;
+        }
+        const blockWithUniqueId = {
+            ...block,
+            id: createUniqueRichTextBlockId(seenBlockIds),
+        };
+        seenBlockIds.add(blockWithUniqueId.id);
+        return blockWithUniqueId;
+    });
+}
+function readBlockId(block) {
+    return typeof block.id === "string" && block.id.trim()
+        ? block.id.trim()
+        : createRichTextBlockId();
+}
+function createUniqueRichTextBlockId(existingIds) {
+    let id = createRichTextBlockId();
+    while (existingIds.has(id)) {
+        id = createRichTextBlockId();
+    }
+    return id;
+}
+function markdownToPlainText(value) {
+    return value
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/\*\*([^*]*)\*\*/g, "$1")
+        .replace(/_([^_]*)_/g, "$1")
+        .replace(/\[([^\]]*)\]\([^)]+\)/g, "$1")
+        .replace(/[#>*`_[\]()]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function sanitizeMarkdown(value) {
+    return stripWhitespaceOnlyMarkdown(normalizeTypography(value).replace(/<!--[\s\S]*?-->/g, ""));
+}
+function stripWhitespaceOnlyMarkdown(value) {
+    return value.trim().length > 0 ? value : "";
+}
+function normalizeTypography(value) {
+    const tokens = [];
+    let normalized = value.replace(/`([^`\n]+)`/g, (match) => {
+        return pushToken(tokens, match);
+    });
+    normalized = normalized.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_match, label, href) => {
+        return `[${label}](${pushToken(tokens, href)})`;
+    });
+    normalized = normalized
+        .replace(/––/g, "—")
+        .replace(/–-/g, "—")
+        .replace(/---/g, "—")
+        .replace(/--/g, "–");
+    tokens.forEach((token, index) => {
+        normalized = normalized.replace(tokenPlaceholder(index), token);
+    });
+    return normalized;
+}
+function stripTags(value) {
+    return value.replace(/<[^>]+>/g, "");
+}
+function getSafeAttribute(attrs, name) {
+    const value = getPlainAttribute(attrs, name);
+    const safeValue = getSafeUrl(value);
+    if (!safeValue) {
+        return "";
+    }
+    return escapeAttribute(safeValue);
+}
+function getSafeUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed || /^javascript:/i.test(trimmed)) {
+        return "";
+    }
+    return trimmed;
+}
+function getPlainAttribute(attrs, name) {
+    const pattern = new RegExp(`${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, "i");
+    const match = attrs.match(pattern);
+    return match?.[2] ?? match?.[3] ?? match?.[4] ?? "";
+}
+function escapeAttribute(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function escapeHtmlText(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function decodeHtmlText(value) {
+    return value
+        .replace(/&nbsp;/g, " ")
+        .replace(/&#160;/g, " ")
+        .replace(/&#xA0;/gi, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#39;/g, "'");
+}
+function pushToken(tokens, value) {
+    const index = tokens.push(value) - 1;
+    return tokenPlaceholder(index);
+}
+function tokenPlaceholder(index) {
+    return `@@RICHTEXTTOKEN${index}@@`;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function readImageAlignment(value) {
+    return value === "left" || value === "right" ? value : "center";
+}
+function readImageDisplaySize(value) {
+    return value === "small" ||
+        value === "medium" ||
+        value === "full" ||
+        value === "custom"
+        ? value
+        : null;
+}
+function readImageCustomWidth(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    return clamp(Math.round(value), 120, 1600);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,78 @@
+export type RichTextJsonValue = null | boolean | number | string | RichTextJsonValue[] | {
+    [key: string]: RichTextJsonValue;
+};
+export type RichTextToolStatus = "pending" | "success" | "error";
+export type RichTextImageDisplaySize = "small" | "medium" | "full" | "custom";
+export type RichTextBlock = {
+    id: string;
+    type: "paragraph";
+    markdown: string;
+} | {
+    id: string;
+    type: "message";
+    markdown: string;
+} | {
+    id: string;
+    type: "heading";
+    markdown: string;
+} | {
+    id: string;
+    type: "quote";
+    markdown: string;
+} | {
+    id: string;
+    type: "bullet";
+    markdown: string;
+    children?: RichTextBlock[];
+} | {
+    id: string;
+    type: "ordered";
+    markdown: string;
+    children?: RichTextBlock[];
+} | {
+    id: string;
+    type: "checkbox";
+    checked: boolean;
+    markdown: string;
+    children?: RichTextBlock[];
+} | {
+    id: string;
+    type: "toggle";
+    collapsed: boolean;
+    markdown: string;
+    children: RichTextBlock[];
+} | {
+    id: string;
+    type: "code";
+    text: string;
+} | {
+    id: string;
+    type: "divider";
+} | {
+    id: string;
+    type: "tool";
+    toolType: string;
+    status: RichTextToolStatus;
+    title?: string;
+    markdown?: string;
+    data?: RichTextJsonValue;
+} | {
+    id: string;
+    type: "image";
+    alignment?: "center" | "left" | "right";
+    alt?: string;
+    customWidth?: number;
+    displaySize?: RichTextImageDisplaySize;
+    uploadProgress?: number;
+    url?: string;
+};
+export type RichTextBlockPath = number[];
+export type RichTextSelectionSnapshot = {
+    affinity: "start" | "end";
+    blockId: string;
+    offset: number;
+};
+export type RichTextDocument = {
+    contentBlocks: RichTextBlock[];
+    title: string;
+};

package/dist/index.d.ts

@@ -1,8 +1,14 @@
-export { canonicalSerialize, createEditorSession, defaultEditorSessionEquals, } from "./session";
-export { getEditorSaveControlState } from "./saveControl";
-export { createEditorSessionRegistry } from "./sessionRegistry";
-export { createEmptyRichTextBlocks, createRichTextBlockId, editorHtmlToMarkdown, isRichTextBlocksEmpty, markdownToEditorHtml, richTextBlocksToPlainText, sanitizeRichTextBlocks, sanitizeRichTextHtml, } from "./richText";
-export { getWritingStats } from "./writingStats";
-export type { EditorDirtyScope, EditorSession, EditorSessionOptions, EditorSessionValue, } from "./session";
-export type { EditorExitAction, EditorSessionRegistry, EditorSessionRegistrySnapshot, } from "./sessionRegistry";
-export type { RichTextBlock, RichTextDocument } from "./types";
+export { canonicalSerialize, createEditorSession, defaultEditorSessionEquals, } from "./session/session";
+export { getEditorSaveControlState } from "./session/saveControl";
+export { createEditorSessionRegistry } from "./session/sessionRegistry";
+export { createEmptyRichTextBlocks, createRichTextBlockId, decodeRichTextBlocksFromClipboardText, encodeRichTextBlocksForClipboard, editorHtmlToMarkdown, isRichTextBlocksEmpty, markdownToEditorHtml, richTextBlocksToPlainText, sanitizeRichTextBlocks, sanitizeRichTextHtml, } from "./core/richText";
+export { getRichTextFeatureAccess, isRichTextFeatureEnabled, richTextEditorFeatureCatalog, } from "./core/features";
+export { exportRichTextBlocks, importRichTextBlocks, richTextJsonExportAdapter, richTextJsonImportAdapter, } from "./core/exportImport";
+export { connectRichTextCollaboration, createRichTextAnnotations, instantiateRichTextTemplate, runRichTextSchemaMigrations, } from "./core/proFeatures";
+export { getWritingStats } from "./core/writingStats";
+export type { RichTextExportAdapter, RichTextExportImportResult, RichTextExportPayload, RichTextImportAdapter, } from "./core/exportImport";
+export type { RichTextAnnotation, RichTextCollaborationAdapter, RichTextSchemaMigration, RichTextSchemaMigrationResult, RichTextTemplate, } from "./core/proFeatures";
+export type { RichTextEditorEntitlements, RichTextEditorFeatureId, RichTextEditorFeatureTier, RichTextFeatureAccess, RichTextFeatureGate, RichTextFeatureGateReason, RichTextLockedFeatureMode, } from "./core/features";
+export type { EditorDirtyScope, EditorSession, EditorSessionOptions, EditorSessionValue, } from "./session/session";
+export type { EditorExitAction, EditorSessionRegistry, EditorSessionRegistrySnapshot, } from "./session/sessionRegistry";
+export type { RichTextBlock, RichTextBlockPath, RichTextDocument, RichTextJsonValue, RichTextSelectionSnapshot, RichTextToolStatus, } from "./core/types";

package/dist/index.js

@@ -1,5 +1,8 @@
-export { canonicalSerialize, createEditorSession, defaultEditorSessionEquals, } from "./session.js";
-export { getEditorSaveControlState } from "./saveControl.js";
-export { createEditorSessionRegistry } from "./sessionRegistry.js";
-export { createEmptyRichTextBlocks, createRichTextBlockId, editorHtmlToMarkdown, isRichTextBlocksEmpty, markdownToEditorHtml, richTextBlocksToPlainText, sanitizeRichTextBlocks, sanitizeRichTextHtml, } from "./richText.js";
-export { getWritingStats } from "./writingStats.js";
+export { canonicalSerialize, createEditorSession, defaultEditorSessionEquals, } from "./session/session.js";
+export { getEditorSaveControlState } from "./session/saveControl.js";
+export { createEditorSessionRegistry } from "./session/sessionRegistry.js";
+export { createEmptyRichTextBlocks, createRichTextBlockId, decodeRichTextBlocksFromClipboardText, encodeRichTextBlocksForClipboard, editorHtmlToMarkdown, isRichTextBlocksEmpty, markdownToEditorHtml, richTextBlocksToPlainText, sanitizeRichTextBlocks, sanitizeRichTextHtml, } from "./core/richText.js";
+export { getRichTextFeatureAccess, isRichTextFeatureEnabled, richTextEditorFeatureCatalog, } from "./core/features.js";
+export { exportRichTextBlocks, importRichTextBlocks, richTextJsonExportAdapter, richTextJsonImportAdapter, } from "./core/exportImport.js";
+export { connectRichTextCollaboration, createRichTextAnnotations, instantiateRichTextTemplate, runRichTextSchemaMigrations, } from "./core/proFeatures.js";
+export { getWritingStats } from "./core/writingStats.js";