smartrte-core 0.2.1 → 1.0.0-beta.1

package/dist/listScope.js

@@ -0,0 +1,104 @@
+import { getNodeAtPath } from "./model.js";
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const isBlock = (node) => Boolean(node) && typeof node === "object" &&
+    ["paragraph", "heading", "list", "blockquote", "codeBlock", "table"].includes(node.type || "");
+const structuralUnit = (document, path) => {
+    let firstBlockPath = null;
+    let deepestList = null;
+    for (let depth = 1; depth <= path.length; depth += 1) {
+        const candidatePath = path.slice(0, depth);
+        const node = getNodeAtPath(document, candidatePath);
+        if (!isBlock(node))
+            continue;
+        if (!firstBlockPath)
+            firstBlockPath = candidatePath;
+        if (node.type === "list") {
+            const itemIndex = path[depth];
+            deepestList = {
+                path: candidatePath,
+                listItemIndex: Number.isInteger(itemIndex) ? itemIndex : undefined,
+            };
+            continue;
+        }
+        if (node.type === "table")
+            firstBlockPath = null;
+    }
+    return deepestList || (firstBlockPath ? { path: firstBlockPath, listItemIndex: undefined } : null);
+};
+/** Resolves the semantic list scope without inspecting DOM details. */
+export const resolveListSelectionScope = (document, selection) => {
+    if (selection.type === "all")
+        return { kind: "all", containerPath: [] };
+    if (selection.type !== "text" && selection.type !== "node")
+        return { kind: "none" };
+    const paths = selection.type === "text"
+        ? [selection.anchor.path, selection.focus.path]
+        : [selection.path, selection.path];
+    const anchor = structuralUnit(document, paths[0]);
+    const focus = structuralUnit(document, paths[1]);
+    if (!anchor || !focus)
+        return { kind: "none" };
+    if (samePath(anchor.path, focus.path) && anchor.listItemIndex !== undefined && focus.listItemIndex !== undefined) {
+        return {
+            kind: "list",
+            listPath: anchor.path,
+            start: Math.min(anchor.listItemIndex, focus.listItemIndex),
+            end: Math.max(anchor.listItemIndex, focus.listItemIndex),
+        };
+    }
+    // A range whose endpoints are list content at different depths belongs to
+    // the nearest common containing list. For example, selecting a parent item
+    // through one of its nested items changes the parent list while preserving
+    // the nested descendants. A nested-only range is handled by the same-path
+    // branch above and therefore remains scoped to the nested list.
+    if (anchor.listItemIndex !== undefined && focus.listItemIndex !== undefined) {
+        const listPaths = [anchor.path, focus.path];
+        const ancestor = listPaths.find((candidate) => listPaths.every((path) => path.length >= candidate.length && candidate.every((part, index) => path[index] === part)));
+        if (ancestor) {
+            const indices = [
+                samePath(anchor.path, ancestor) ? anchor.listItemIndex : anchor.path[ancestor.length],
+                samePath(focus.path, ancestor) ? focus.listItemIndex : focus.path[ancestor.length],
+            ]
+                .filter((index) => Number.isInteger(index));
+            if (indices.length === 2) {
+                return {
+                    kind: "list",
+                    listPath: ancestor,
+                    start: Math.min(...indices),
+                    end: Math.max(...indices),
+                };
+            }
+        }
+    }
+    const mixed = [anchor, focus].find((unit) => unit.listItemIndex !== undefined);
+    const plain = [anchor, focus].find((unit) => unit.listItemIndex === undefined);
+    if (mixed && plain) {
+        let outerListPath = null;
+        for (let depth = 1; depth <= mixed.path.length; depth += 1) {
+            if (getNodeAtPath(document, mixed.path.slice(0, depth))?.type === "list") {
+                outerListPath = mixed.path.slice(0, depth);
+                break;
+            }
+        }
+        if (!outerListPath || !samePath(outerListPath.slice(0, -1), plain.path.slice(0, -1)))
+            return { kind: "none" };
+        return {
+            kind: "mixed",
+            containerPath: plain.path.slice(0, -1),
+            blockIndex: plain.path[plain.path.length - 1],
+            listPath: outerListPath,
+            itemStart: mixed.path[outerListPath.length],
+            itemEnd: mixed.path[outerListPath.length],
+        };
+    }
+    const anchorParent = anchor.path.slice(0, -1);
+    const focusParent = focus.path.slice(0, -1);
+    if (!samePath(anchorParent, focusParent))
+        return { kind: "none" };
+    return {
+        kind: "blocks",
+        containerPath: anchorParent,
+        start: Math.min(anchor.path[anchor.path.length - 1], focus.path[focus.path.length - 1]),
+        end: Math.max(anchor.path[anchor.path.length - 1], focus.path[focus.path.length - 1]),
+    };
+};

package/dist/markdown/compatibility.d.ts

@@ -5,3 +5,5 @@
  * indentation and table syntax that no HTML repair pass can recover once lost.
  */
 export declare const markdownToCompatibilityHtml: (markdown: string) => string;
+/** Converts canonical HTML to portable GFM with Smart RTE formula syntax. */
+export declare const compatibilityHtmlToMarkdown: (html: string) => string;

package/dist/markdown/compatibility.js

@@ -4,6 +4,19 @@ import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import { unified } from "unified";
 import { normalizeCompatibilityHtml } from "../html/compatibility.js";
+import { parseCompatibilityHtml } from "../html/compatibility.js";
+const escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const extractFormulaPlaceholders = (markdown) => {
+    const formulas = [];
+    const source = markdown.replace(/\$\$([\s\S]+?)\$\$|\$([^$\n]+?)\$/g, (_match, block, inline) => {
+        const value = String(block ?? inline ?? "").trim();
+        if (!value)
+            return _match;
+        const index = formulas.push(value) - 1;
+        return `SMART_RTE_FORMULA_${index}_TOKEN`;
+    });
+    return { source, formulas };
+};
 /**
  * Converts CommonMark/GFM input to canonical Smart RTE HTML.
  *
@@ -11,11 +24,90 @@ import { normalizeCompatibilityHtml } from "../html/compatibility.js";
  * indentation and table syntax that no HTML repair pass can recover once lost.
  */
 export const markdownToCompatibilityHtml = (markdown) => {
+    const { source, formulas } = extractFormulaPlaceholders(markdown);
     const html = String(unified()
         .use(remarkParse)
         .use(remarkGfm)
         .use(remarkRehype)
         .use(rehypeStringify)
-        .processSync(markdown));
-    return normalizeCompatibilityHtml(html);
+        .processSync(source));
+    const withFormulas = formulas.reduce((current, formula, index) => current.replace(new RegExp(`SMART_RTE_FORMULA_${index}_TOKEN`, "g"), `<span data-formula="${escapeAttribute(formula)}">$${escapeAttribute(formula)}$</span>`), html);
+    const withChecklists = withFormulas
+        .replace(/<ul class="contains-task-list">/g, '<ul data-srte-checklist="true">')
+        .replace(/<li class="task-list-item"><input type="checkbox"([^>]*)>\s*/g, (_match, attributes) => `<li data-srte-checked="${/\bchecked(?:\s|=|$)/.test(attributes) ? "true" : "false"}">`);
+    return normalizeCompatibilityHtml(withChecklists);
+};
+const attr = (node, name) => node.attrs?.find((candidate) => candidate.name === name)?.value || "";
+const markdownEscapeText = (value) => value.replace(/\\/g, "\\\\").replace(/([*_`[\]])/g, "\\$1");
+const descendantsByTag = (node, tagName) => (node.childNodes || []).flatMap((child) => [
+    ...(child.tagName === tagName ? [child] : []),
+    ...descendantsByTag(child, tagName),
+]);
+/** Converts canonical HTML to portable GFM with Smart RTE formula syntax. */
+export const compatibilityHtmlToMarkdown = (html) => {
+    const { fragment } = parseCompatibilityHtml(html);
+    const walk = (node, listDepth = 0) => {
+        if (node.nodeName === "#text")
+            return markdownEscapeText(node.value || "");
+        const tag = node.tagName || "";
+        if (tag === "span" && attr(node, "data-formula"))
+            return `$${attr(node, "data-formula")}$`;
+        if (tag === "img")
+            return `![${markdownEscapeText(attr(node, "alt"))}](${attr(node, "src")})`;
+        const content = (node.childNodes || []).map((child) => walk(child, listDepth)).join("");
+        if (tag === "strong" || tag === "b")
+            return `**${content}**`;
+        if (tag === "em" || tag === "i")
+            return `*${content}*`;
+        if (tag === "s" || tag === "del" || tag === "strike")
+            return `~~${content}~~`;
+        if (tag === "code")
+            return `\`${content}\``;
+        if (tag === "a")
+            return `[${content}](${attr(node, "href")})`;
+        if (tag === "br")
+            return "  \n";
+        if (/^h[1-6]$/.test(tag))
+            return `${"#".repeat(Number(tag.slice(1)))} ${content.trim()}\n\n`;
+        if (tag === "p")
+            return `${content.trim()}\n\n`;
+        if (tag === "blockquote") {
+            return `${content.trim().split("\n").map((line) => `> ${line}`).join("\n")}\n\n`;
+        }
+        if (tag === "li") {
+            return `${"  ".repeat(listDepth)}- ${content.trim()}\n`;
+        }
+        if (tag === "ul" || tag === "ol") {
+            const ordered = tag === "ol";
+            const checklist = attr(node, "data-srte-checklist") === "true";
+            return (node.childNodes || []).map((child, index) => {
+                if (child.tagName !== "li")
+                    return walk(child, listDepth + 1);
+                const item = (child.childNodes || []).map((nested) => walk(nested, listDepth + 1)).join("").trim();
+                const marker = checklist
+                    ? `- [${attr(child, "data-srte-checked") === "true" ? "x" : " "}]`
+                    : ordered ? `${index + 1}.` : "-";
+                return `${"  ".repeat(listDepth)}${marker} ${item}\n`;
+            }).join("") + (listDepth === 0 ? "\n" : "");
+        }
+        if (tag === "table") {
+            const rows = descendantsByTag(node, "tr").map((row) => (row.childNodes || [])
+                .filter((cell) => cell.tagName === "td" || cell.tagName === "th")
+                .map((cell) => (cell.childNodes || []).map((child) => walk(child, listDepth)).join("")
+                .replace(/\n+/g, " ").trim().replace(/\|/g, "\\|")));
+            if (!rows.length)
+                return "";
+            const columns = Math.max(...rows.map((row) => row.length));
+            const normalized = rows.map((row) => [...row, ...Array(Math.max(0, columns - row.length)).fill("")]);
+            return [
+                `| ${normalized[0].join(" | ")} |`,
+                `| ${Array(columns).fill("---").join(" | ")} |`,
+                ...normalized.slice(1).map((row) => `| ${row.join(" | ")} |`),
+                "",
+                "",
+            ].join("\n");
+        }
+        return content;
+    };
+    return walk(fragment).replace(/\n{3,}/g, "\n\n").trim();
 };

package/dist/marks.d.ts

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

package/dist/model.d.ts

@@ -1,6 +1,6 @@
 export type Path = readonly number[];
 export type TextAlignment = "left" | "center" | "right" | "justify";
-export type SmartMark = {
+export type LegacySmartMark = {
     type: "bold";
 } | {
     type: "italic";
@@ -23,45 +23,95 @@ export type SmartMark = {
 } | {
     type: "fontSize";
     valuePx: number;
+} | {
+    type: "fontFamily";
+    value: string;
+} | {
+    type: "formula";
+    value: string;
 } | {
     type: "link";
     href: string;
     target?: string;
 };
-export interface SmartTextNode {
+export interface LegacySmartTextNode {
     type: "text";
     text: string;
-    marks?: SmartMark[];
+    marks?: LegacySmartMark[];
 }
+/** An indivisible inline node. Text commands must treat these as length-one atoms. */
+export interface SmartFormulaNode {
+    type: "formula";
+    value: string;
+    displayText?: string;
+}
+export interface SmartInlineImageNode {
+    type: "inlineImage";
+    src: string;
+    alt?: string;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+export type SmartInlineNode = LegacySmartTextNode | SmartFormulaNode | SmartInlineImageNode;
 export interface SmartParagraphNode {
     type: "paragraph";
     alignment?: TextAlignment;
-    children: SmartTextNode[];
+    indent?: number;
+    children: SmartInlineNode[];
 }
 export interface SmartHeadingNode {
     type: "heading";
     level: 1 | 2 | 3 | 4 | 5 | 6;
     alignment?: TextAlignment;
-    children: SmartTextNode[];
+    indent?: number;
+    children: SmartInlineNode[];
 }
 export interface SmartListItemNode {
     type: "listItem";
     alignment?: TextAlignment;
+    checked?: boolean;
     children: SmartBlockNode[];
 }
+export type SmartListStyle = "disc" | "circle" | "square" | "decimal" | "decimal-leading-zero" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+export type SmartListPreset = "bullet-disc" | "bullet-diamond" | "bullet-square" | "bullet-arrow" | "bullet-star" | "bullet-arrow-circle" | "ordered-decimal" | "ordered-decimal-paren" | "ordered-outline" | "ordered-upper-alpha" | "ordered-upper-roman" | "ordered-leading-zero";
 export interface SmartListNode {
     type: "list";
-    style: "disc" | "circle" | "square" | "decimal" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+    indent?: number;
+    style: SmartListStyle;
+    /** Marker family applied to this list hierarchy. `style` remains the portable fallback. */
+    preset?: SmartListPreset;
+    checklist?: boolean;
+    strikeCompleted?: boolean;
     children: SmartListItemNode[];
 }
+export interface SmartImageNode {
+    type: "image";
+    indent?: number;
+    src: string;
+    alt?: string;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+export interface SmartMediaNode {
+    type: "media";
+    indent?: number;
+    src: string;
+    mediaType: "audio" | "video" | "file";
+    title?: string;
+    mimeType?: string;
+}
 export interface SmartBlockquoteNode {
     type: "blockquote";
     alignment?: TextAlignment;
+    indent?: number;
     children: SmartBlockNode[];
 }
 export interface SmartCodeBlockNode {
     type: "codeBlock";
     alignment?: TextAlignment;
+    indent?: number;
     text: string;
     language?: string;
 }
@@ -69,20 +119,26 @@ export interface SmartTableCellNode {
     type: "tableCell" | "tableHeaderCell";
     colspan?: number;
     rowspan?: number;
+    backgroundColor?: string;
+    textColor?: string;
+    border?: string;
     children: SmartBlockNode[];
 }
 export interface SmartTableRowNode {
     type: "tableRow";
+    heightPx?: number;
     children: SmartTableCellNode[];
 }
 export interface SmartTableNode {
     type: "table";
+    indent?: number;
+    columnWidths?: number[];
     children: SmartTableRowNode[];
 }
-export type SmartBlockNode = SmartParagraphNode | SmartHeadingNode | SmartListNode | SmartBlockquoteNode | SmartCodeBlockNode | SmartTableNode;
-export interface SmartDocument {
+export type SmartBlockNode = SmartParagraphNode | SmartHeadingNode | SmartListNode | SmartBlockquoteNode | SmartCodeBlockNode | SmartImageNode | SmartMediaNode | SmartTableNode;
+export interface LegacySmartDocument {
     type: "doc";
     children: SmartBlockNode[];
 }
 export declare const paragraph: (text?: string) => SmartParagraphNode;
-export declare const getNodeAtPath: (document: SmartDocument, path: Path) => unknown;
+export declare const getNodeAtPath: (document: LegacySmartDocument, path: Path) => unknown;

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+import type { SmartCommand } from "./command.js";
+import type { LegacySmartDocument } from "./model.js";
+import type { SmartSchemaExtension } from "./schema.js";
+import type { LegacySmartTransaction } from "./transaction.js";
+export type SmartPluginCommand = SmartCommand<any>;
+export type SmartNormalizer = (document: LegacySmartDocument) => LegacySmartDocument;
+export interface SmartRtePlugin {
+    id: string;
+    dependencies?: string[];
+    commands?: Record<string, SmartPluginCommand>;
+    schema?: Omit<SmartSchemaExtension, "id">;
+    normalizers?: SmartNormalizer[];
+    onTransaction?: (transaction: LegacySmartTransaction) => void;
+}
+export declare const orderPlugins: (plugins: readonly SmartRtePlugin[]) => SmartRtePlugin[];

package/dist/plugin.js

@@ -0,0 +1,31 @@
+export const orderPlugins = (plugins) => {
+    const byId = new Map();
+    plugins.forEach((plugin) => {
+        if (!plugin.id.trim())
+            throw new Error("Plugin id cannot be empty.");
+        if (byId.has(plugin.id))
+            throw new Error(`Duplicate plugin id "${plugin.id}".`);
+        byId.set(plugin.id, plugin);
+    });
+    const ordered = [];
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (plugin) => {
+        if (visited.has(plugin.id))
+            return;
+        if (visiting.has(plugin.id))
+            throw new Error(`Circular plugin dependency involving "${plugin.id}".`);
+        visiting.add(plugin.id);
+        (plugin.dependencies || []).forEach((dependency) => {
+            const required = byId.get(dependency);
+            if (!required)
+                throw new Error(`Plugin "${plugin.id}" requires missing plugin "${dependency}".`);
+            visit(required);
+        });
+        visiting.delete(plugin.id);
+        visited.add(plugin.id);
+        ordered.push(plugin);
+    };
+    plugins.forEach(visit);
+    return ordered;
+};

package/dist/plugins/alignment.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createAlignmentPlugin: () => SmartRtePlugin;
+export declare const alignmentPlugin: SmartRtePlugin;

package/dist/plugins/alignment.js

@@ -0,0 +1,6 @@
+import { setAlignment } from "../legacyCommands/alignment.js";
+export const createAlignmentPlugin = () => ({
+    id: "alignment",
+    commands: { [setAlignment.id]: setAlignment },
+});
+export const alignmentPlugin = createAlignmentPlugin();

package/dist/plugins/basicFormatting.d.ts

@@ -0,0 +1,9 @@
+import type { SmartRtePlugin } from "../plugin.js";
+/**
+ * Inline formatting as an independently selectable feature bundle.
+ *
+ * Applications may use the singleton or create a fresh plugin descriptor when
+ * composing an editor preset. Commands remain model-only and UI-framework-free.
+ */
+export declare const createBasicFormattingPlugin: () => SmartRtePlugin;
+export declare const basicFormattingPlugin: SmartRtePlugin;

package/dist/plugins/basicFormatting.js

@@ -0,0 +1,24 @@
+import { applyBackgroundColor, applyFontSize, applyFontFamily, applyTextColor, toggleBold, toggleInlineCode, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline, } from "../legacyCommands/marks.js";
+/**
+ * Inline formatting as an independently selectable feature bundle.
+ *
+ * Applications may use the singleton or create a fresh plugin descriptor when
+ * composing an editor preset. Commands remain model-only and UI-framework-free.
+ */
+export const createBasicFormattingPlugin = () => ({
+    id: "basic-formatting",
+    commands: {
+        [toggleBold.id]: toggleBold,
+        [toggleItalic.id]: toggleItalic,
+        [toggleUnderline.id]: toggleUnderline,
+        [toggleStrike.id]: toggleStrike,
+        [toggleInlineCode.id]: toggleInlineCode,
+        [toggleSuperscript.id]: toggleSuperscript,
+        [toggleSubscript.id]: toggleSubscript,
+        [applyTextColor.id]: applyTextColor,
+        [applyBackgroundColor.id]: applyBackgroundColor,
+        [applyFontSize.id]: applyFontSize,
+        [applyFontFamily.id]: applyFontFamily,
+    },
+});
+export const basicFormattingPlugin = createBasicFormattingPlugin();

package/dist/plugins/blockType.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createBlockTypePlugin: () => SmartRtePlugin;
+export declare const blockTypePlugin: SmartRtePlugin;

package/dist/plugins/blockType.js

@@ -0,0 +1,6 @@
+import { setBlockType } from "../legacyCommands/blocks.js";
+export const createBlockTypePlugin = () => ({
+    id: "block-type",
+    commands: { [setBlockType.id]: setBlockType },
+});
+export const blockTypePlugin = createBlockTypePlugin();

package/dist/plugins/blockquote.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createBlockquotePlugin: () => SmartRtePlugin;
+export declare const blockquotePlugin: SmartRtePlugin;

package/dist/plugins/blockquote.js

@@ -0,0 +1,6 @@
+import { toggleBlockquote } from "../legacyCommands/blocks.js";
+export const createBlockquotePlugin = () => ({
+    id: "blockquote",
+    commands: { [toggleBlockquote.id]: toggleBlockquote },
+});
+export const blockquotePlugin = createBlockquotePlugin();

package/dist/plugins/checklist.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createChecklistPlugin: () => SmartRtePlugin;
+export declare const checklistPlugin: SmartRtePlugin;

package/dist/plugins/checklist.js

@@ -0,0 +1,10 @@
+import { setChecklistItemChecked, toggleChecklist } from "../legacyCommands/checklist.js";
+export const createChecklistPlugin = () => ({
+    id: "checklist",
+    dependencies: ["list"],
+    commands: {
+        [toggleChecklist.id]: toggleChecklist,
+        [setChecklistItemChecked.id]: setChecklistItemChecked,
+    },
+});
+export const checklistPlugin = createChecklistPlugin();

package/dist/plugins/codeBlock.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createCodeBlockPlugin: () => SmartRtePlugin;
+export declare const codeBlockPlugin: SmartRtePlugin;

package/dist/plugins/codeBlock.js

@@ -0,0 +1,6 @@
+import { toggleCodeBlock } from "../legacyCommands/code.js";
+export const createCodeBlockPlugin = () => ({
+    id: "code-block",
+    commands: { [toggleCodeBlock.id]: toggleCodeBlock },
+});
+export const codeBlockPlugin = createCodeBlockPlugin();

package/dist/plugins/formula.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createFormulaPlugin: () => SmartRtePlugin;
+export declare const formulaPlugin: SmartRtePlugin;

package/dist/plugins/formula.js

@@ -0,0 +1,9 @@
+import { deleteFormula, insertFormula } from "../legacyCommands/formula.js";
+export const createFormulaPlugin = () => ({
+    id: "formula",
+    commands: {
+        [insertFormula.id]: insertFormula,
+        [deleteFormula.id]: deleteFormula,
+    },
+});
+export const formulaPlugin = createFormulaPlugin();

package/dist/plugins/list.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createListPlugin: () => SmartRtePlugin;
+export declare const listPlugin: SmartRtePlugin;

package/dist/plugins/list.js

@@ -0,0 +1,10 @@
+import { indentListItems, outdentListItems, toggleList } from "../legacyCommands/list.js";
+export const createListPlugin = () => ({
+    id: "list",
+    commands: {
+        [toggleList.id]: toggleList,
+        [indentListItems.id]: indentListItems,
+        [outdentListItems.id]: outdentListItems,
+    },
+});
+export const listPlugin = createListPlugin();

package/dist/plugins/media.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createMediaPlugin: () => SmartRtePlugin;
+export declare const mediaPlugin: SmartRtePlugin;

package/dist/plugins/media.js

@@ -0,0 +1,12 @@
+import { deleteInlineImage, insertImage, insertInlineImage, insertMedia, updateInlineImage, } from "../legacyCommands/media.js";
+export const createMediaPlugin = () => ({
+    id: "media",
+    commands: {
+        [insertImage.id]: insertImage,
+        [insertInlineImage.id]: insertInlineImage,
+        [deleteInlineImage.id]: deleteInlineImage,
+        [updateInlineImage.id]: updateInlineImage,
+        [insertMedia.id]: insertMedia,
+    },
+});
+export const mediaPlugin = createMediaPlugin();

package/dist/plugins/move.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createMovePlugin: () => SmartRtePlugin;
+export declare const movePlugin: SmartRtePlugin;

package/dist/plugins/move.js

@@ -0,0 +1,9 @@
+import { indentBlocks, moveBlocks } from "../legacyCommands/move.js";
+export const createMovePlugin = () => ({
+    id: "move",
+    commands: {
+        [moveBlocks.id]: moveBlocks,
+        [indentBlocks.id]: indentBlocks,
+    },
+});
+export const movePlugin = createMovePlugin();

package/dist/plugins/table.d.ts

@@ -0,0 +1,3 @@
+import type { SmartRtePlugin } from "../plugin.js";
+export declare const createTablePlugin: () => SmartRtePlugin;
+export declare const tablePlugin: SmartRtePlugin;

package/dist/plugins/table.js

@@ -0,0 +1,22 @@
+import { addTableColumn, addTableRow, insertTable, mergeTableCells, removeTable, removeTableColumn, removeTableRow, setTableCellStyle, setTableColumnWidth, setTableRowHeight, splitTableCell, toggleTableHeaderCell, toggleTableHeaderColumn, toggleTableHeaderRow, toggleTableCellBorder, } from "../legacyCommands/table.js";
+export const createTablePlugin = () => ({
+    id: "table",
+    commands: {
+        [insertTable.id]: insertTable,
+        [removeTable.id]: removeTable,
+        [addTableRow.id]: addTableRow,
+        [removeTableRow.id]: removeTableRow,
+        [addTableColumn.id]: addTableColumn,
+        [removeTableColumn.id]: removeTableColumn,
+        [setTableCellStyle.id]: setTableCellStyle,
+        [setTableColumnWidth.id]: setTableColumnWidth,
+        [setTableRowHeight.id]: setTableRowHeight,
+        [mergeTableCells.id]: mergeTableCells,
+        [splitTableCell.id]: splitTableCell,
+        [toggleTableHeaderCell.id]: toggleTableHeaderCell,
+        [toggleTableHeaderRow.id]: toggleTableHeaderRow,
+        [toggleTableHeaderColumn.id]: toggleTableHeaderColumn,
+        [toggleTableCellBorder.id]: toggleTableCellBorder,
+    },
+});
+export const tablePlugin = createTablePlugin();

package/dist/preset.d.ts

@@ -0,0 +1,12 @@
+import type { SmartRtePlugin } from "./plugin.js";
+export type CoreFeatureId = "basicFormatting" | "blockType" | "alignment" | "list" | "checklist" | "blockquote" | "codeBlock" | "table" | "media" | "formula" | "move";
+export type CoreFeatureConfig = Partial<Record<CoreFeatureId, boolean>>;
+/**
+ * Creates the standard model plugin set.
+ *
+ * Features default to enabled. Disabling `list` also disables `checklist`,
+ * because checklist commands depend on list structure. Applications can append
+ * custom plugins to the returned array before constructing an editor.
+ */
+export declare const createCorePlugins: (config?: CoreFeatureConfig) => SmartRtePlugin[];
+export declare const corePlugins: SmartRtePlugin[];