smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/legacy/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Compatibility API for features that have not migrated to the foundation
+ * contracts. Contract names are deliberately prefixed with `Legacy`; the
+ * canonical unprefixed names belong to the package root/foundation kernel.
+ */
+export * from "../model.js";
+export * from "../command.js";
+export * from "../editor.js";
+export * from "../marks.js";
+export * from "../plugin.js";
+export * from "../preset.js";
+export * from "../history.js";
+export * from "../selection.js";
+export * from "../listScope.js";
+export * from "../listPresets.js";
+export * from "../selectionMapping.js";
+export * from "../schema.js";
+export * from "../table.js";
+export * from "../transaction.js";
+export * from "../tree.js";
+export * from "../legacyCommands/list.js";
+export * from "../legacyCommands/code.js";
+export * from "../legacyCommands/marks.js";
+export * from "../legacyCommands/alignment.js";
+export * from "../legacyCommands/checklist.js";
+export * from "../legacyCommands/media.js";
+export * from "../legacyCommands/formula.js";
+export * from "../legacyCommands/inlineAtoms.js";
+export * from "../legacyCommands/blocks.js";
+export * from "../legacyCommands/table.js";
+export * from "../legacyCommands/move.js";
+export * from "../plugins/basicFormatting.js";
+export * from "../plugins/list.js";
+export * from "../plugins/checklist.js";
+export * from "../plugins/media.js";
+export * from "../plugins/formula.js";
+export * from "../plugins/alignment.js";
+export * from "../plugins/codeBlock.js";
+export * from "../plugins/blockType.js";
+export * from "../plugins/blockquote.js";
+export * from "../plugins/table.js";
+export * from "../plugins/move.js";
+export * from "../html/compatibility.js";
+export * from "../markdown/compatibility.js";
+export * from "../security/urlPolicy.js";

package/dist/legacy/index.js

@@ -0,0 +1,45 @@
+/**
+ * Compatibility API for features that have not migrated to the foundation
+ * contracts. Contract names are deliberately prefixed with `Legacy`; the
+ * canonical unprefixed names belong to the package root/foundation kernel.
+ */
+export * from "../model.js";
+export * from "../command.js";
+export * from "../editor.js";
+export * from "../marks.js";
+export * from "../plugin.js";
+export * from "../preset.js";
+export * from "../history.js";
+export * from "../selection.js";
+export * from "../listScope.js";
+export * from "../listPresets.js";
+export * from "../selectionMapping.js";
+export * from "../schema.js";
+export * from "../table.js";
+export * from "../transaction.js";
+export * from "../tree.js";
+export * from "../legacyCommands/list.js";
+export * from "../legacyCommands/code.js";
+export * from "../legacyCommands/marks.js";
+export * from "../legacyCommands/alignment.js";
+export * from "../legacyCommands/checklist.js";
+export * from "../legacyCommands/media.js";
+export * from "../legacyCommands/formula.js";
+export * from "../legacyCommands/inlineAtoms.js";
+export * from "../legacyCommands/blocks.js";
+export * from "../legacyCommands/table.js";
+export * from "../legacyCommands/move.js";
+export * from "../plugins/basicFormatting.js";
+export * from "../plugins/list.js";
+export * from "../plugins/checklist.js";
+export * from "../plugins/media.js";
+export * from "../plugins/formula.js";
+export * from "../plugins/alignment.js";
+export * from "../plugins/codeBlock.js";
+export * from "../plugins/blockType.js";
+export * from "../plugins/blockquote.js";
+export * from "../plugins/table.js";
+export * from "../plugins/move.js";
+export * from "../html/compatibility.js";
+export * from "../markdown/compatibility.js";
+export * from "../security/urlPolicy.js";

package/dist/legacyCommands/alignment.d.ts

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

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

@@ -32,3 +32,20 @@ export const setTextAlignment = (document, selection, input) => {
         },
     };
 };
+export const setAlignment = {
+    id: "alignment.set",
+    isEnabled: (context, input) => {
+        if (!input?.paths.length)
+            return false;
+        return input.paths.every((path) => {
+            const type = getNodeAtPath(context.document, path)?.type;
+            return ["paragraph", "heading", "listItem", "blockquote", "codeBlock"].includes(type || "");
+        });
+    },
+    execute: (context, input) => {
+        if (!input || !setAlignment.isEnabled(context, input)) {
+            throw new Error("alignment.set requires alignable block paths.");
+        }
+        return setTextAlignment(context.document, context.selection, input).transaction;
+    },
+};

package/dist/legacyCommands/blocks.d.ts

@@ -0,0 +1,14 @@
+import type { SmartCommand } from "../command.js";
+import { type Path, type SmartHeadingNode } from "../model.js";
+export interface SetBlockTypeInput {
+    parentPath: Path;
+    blockIndexes: readonly number[];
+    type: "paragraph" | "heading";
+    level?: SmartHeadingNode["level"];
+}
+export declare const setBlockType: SmartCommand<SetBlockTypeInput>;
+export interface ToggleBlockquoteInput {
+    parentPath: Path;
+    blockIndexes: readonly number[];
+}
+export declare const toggleBlockquote: SmartCommand<ToggleBlockquoteInput>;

package/dist/legacyCommands/blocks.js

@@ -0,0 +1,105 @@
+import { getNodeAtPath, paragraph, } from "../model.js";
+import { isSmartContainer } from "../tree.js";
+const selectedSiblingBlocks = (context, parentPath, indexes) => {
+    const parent = getNodeAtPath(context.document, parentPath);
+    const unique = [...new Set(indexes)].sort((a, b) => a - b);
+    if (!isSmartContainer(parent) || !unique.length)
+        return null;
+    if (unique.some((index) => index < 0 || index >= parent.children.length))
+        return null;
+    return { parent, indexes: unique };
+};
+export const setBlockType = {
+    id: "block-type.set",
+    isEnabled: (context, input) => {
+        if (!input || input.type === "heading" &&
+            (!Number.isInteger(input.level) || (input.level || 0) < 1 || (input.level || 0) > 6))
+            return false;
+        const selected = selectedSiblingBlocks(context, input.parentPath, input.blockIndexes);
+        return Boolean(selected && selected.indexes.every((index) => {
+            const type = selected.parent.children[index].type;
+            return type === "paragraph" || type === "heading";
+        }));
+    },
+    execute: (context, input) => {
+        if (!input || !setBlockType.isEnabled(context, input)) {
+            throw new Error("block-type.set requires paragraph or heading sibling blocks.");
+        }
+        const selected = selectedSiblingBlocks(context, input.parentPath, input.blockIndexes);
+        const indexSet = new Set(selected.indexes);
+        const children = selected.parent.children.map((node, index) => {
+            if (!indexSet.has(index))
+                return node;
+            const block = node;
+            return input.type === "paragraph"
+                ? { type: "paragraph", ...(block.alignment ? { alignment: block.alignment } : {}), children: block.children }
+                : {
+                    type: "heading",
+                    level: input.level,
+                    ...(block.alignment ? { alignment: block.alignment } : {}),
+                    children: block.children.map((child) => {
+                        if (child.type !== "text")
+                            return child;
+                        const marks = child.marks?.filter((mark) => mark.type !== "fontSize");
+                        return marks?.length
+                            ? { ...child, marks }
+                            : { type: "text", text: child.text };
+                    }),
+                };
+        });
+        return {
+            id: "block-type.set",
+            source: "user",
+            operations: [{
+                    type: "replaceNode",
+                    path: input.parentPath,
+                    node: { ...selected.parent, children },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: context.selection,
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+export const toggleBlockquote = {
+    id: "blockquote.toggle",
+    isEnabled: (context, input) => {
+        const selected = input && selectedSiblingBlocks(context, input.parentPath, input.blockIndexes);
+        if (!selected)
+            return false;
+        return selected.indexes.every((index, offset) => offset === 0 || index === selected.indexes[offset - 1] + 1);
+    },
+    execute: (context, input) => {
+        if (!input || !toggleBlockquote.isEnabled(context, input)) {
+            throw new Error("blockquote.toggle requires contiguous sibling blocks.");
+        }
+        const selected = selectedSiblingBlocks(context, input.parentPath, input.blockIndexes);
+        const first = selected.indexes[0];
+        const last = selected.indexes[selected.indexes.length - 1];
+        const blocks = selected.parent.children.slice(first, last + 1);
+        const replacement = blocks.every((block) => block.type === "blockquote")
+            ? blocks.flatMap((block) => block.type === "blockquote" ? block.children : [block])
+            : [{ type: "blockquote", children: blocks.length ? blocks : [paragraph()] }];
+        return {
+            id: "blockquote.toggle",
+            source: "user",
+            operations: [{
+                    type: "replaceNode",
+                    path: input.parentPath,
+                    node: {
+                        ...selected.parent,
+                        children: [
+                            ...selected.parent.children.slice(0, first),
+                            ...replacement,
+                            ...selected.parent.children.slice(last + 1),
+                        ],
+                    },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: { type: "node", path: [...input.parentPath, first] },
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};

package/dist/legacyCommands/checklist.d.ts

@@ -0,0 +1,11 @@
+import type { SmartCommand } from "../command.js";
+import { type Path } from "../model.js";
+export interface ToggleChecklistInput {
+    strikeCompleted?: boolean;
+}
+export declare const toggleChecklist: SmartCommand<ToggleChecklistInput>;
+export interface SetChecklistItemInput {
+    path: Path;
+    checked?: boolean;
+}
+export declare const setChecklistItemChecked: SmartCommand<SetChecklistItemInput>;

package/dist/legacyCommands/checklist.js

@@ -0,0 +1,45 @@
+import { getNodeAtPath } from "../model.js";
+import { toggleList } from "./list.js";
+export const toggleChecklist = {
+    id: "checklist.toggle",
+    isEnabled: (context) => toggleList.isEnabled(context, { style: "disc", checklist: true }),
+    execute: (context, input) => ({
+        ...toggleList.execute(context, {
+            style: "disc",
+            checklist: true,
+            strikeCompleted: input?.strikeCompleted,
+        }),
+        id: "checklist.toggle",
+    }),
+};
+export const setChecklistItemChecked = {
+    id: "checklist.set-checked",
+    isEnabled: (context, input) => {
+        if (!input)
+            return false;
+        const item = getNodeAtPath(context.document, input.path);
+        const list = getNodeAtPath(context.document, input.path.slice(0, -1));
+        return item?.type === "listItem" &&
+            list?.type === "list" &&
+            Boolean(list.checklist);
+    },
+    execute: (context, input) => {
+        if (!input || !setChecklistItemChecked.isEnabled(context, input)) {
+            throw new Error("checklist.set-checked requires an item in a checklist.");
+        }
+        const item = getNodeAtPath(context.document, input.path);
+        return {
+            id: "checklist.set-checked",
+            source: "user",
+            operations: [{
+                    type: "setNodeAttrs",
+                    path: input.path,
+                    attrs: { checked: input.checked ?? !item.checked },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: context.selection,
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};

package/dist/legacyCommands/code.d.ts

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

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

@@ -6,7 +6,13 @@ const toCodeBlock = (block) => {
     if (block.type === "paragraph" || block.type === "heading") {
         return {
             type: "codeBlock",
-            text: block.children.map((child) => child.text).join(""),
+            text: block.children.map((child) => {
+                if (child.type === "text")
+                    return child.text;
+                if (child.type === "formula")
+                    return child.displayText ?? child.value;
+                return child.alt ?? "";
+            }).join(""),
         };
     }
     throw new Error(`Cannot convert ${block.type} to a code block.`);
@@ -54,3 +60,21 @@ export const toggleCodeBlocks = (document, selection, input) => {
         },
     };
 };
+export const toggleCodeBlock = {
+    id: "code-block.toggle",
+    isEnabled: (context, input) => {
+        if (!input?.blockIndexes.length)
+            return false;
+        const parent = getNodeAtPath(context.document, input.parentPath);
+        return isSmartContainer(parent) && input.blockIndexes.every((index) => {
+            const type = parent.children[index]?.type;
+            return type === "paragraph" || type === "heading" || type === "codeBlock";
+        });
+    },
+    execute: (context, input) => {
+        if (!input || !toggleCodeBlock.isEnabled(context, input)) {
+            throw new Error("code-block.toggle requires convertible sibling blocks.");
+        }
+        return toggleCodeBlocks(context.document, context.selection, input).transaction;
+    },
+};

package/dist/legacyCommands/formula.d.ts

@@ -0,0 +1,7 @@
+import type { SmartCommand } from "../command.js";
+export interface InsertFormulaInput {
+    value: string;
+    displayText?: string;
+}
+export declare const insertFormula: SmartCommand<InsertFormulaInput>;
+export declare const deleteFormula: SmartCommand<import("./inlineAtoms.js").InlineAtomPathInput>;

package/dist/legacyCommands/formula.js

@@ -0,0 +1,67 @@
+import { getNodeAtPath } from "../model.js";
+import { isSmartContainer } from "../tree.js";
+import { createDeleteInlineAtomCommand } from "./inlineAtoms.js";
+const resolveFormulaTarget = (context, input) => {
+    if (!input?.value.trim() || context.selection.type !== "text")
+        return null;
+    const { anchor, focus } = context.selection;
+    if (anchor.offset !== focus.offset ||
+        anchor.path.length !== focus.path.length ||
+        !anchor.path.every((part, index) => focus.path[index] === part))
+        return null;
+    const node = getNodeAtPath(context.document, anchor.path);
+    const parentPath = anchor.path.slice(0, -1);
+    const parent = getNodeAtPath(context.document, parentPath);
+    if (node?.type !== "text" || !isSmartContainer(parent) ||
+        anchor.offset < 0 || anchor.offset > node.text.length)
+        return null;
+    return { node, parent, parentPath, index: anchor.path[anchor.path.length - 1], offset: anchor.offset };
+};
+export const insertFormula = {
+    id: "formula.insert",
+    isEnabled: (context, input) => Boolean(resolveFormulaTarget(context, input)),
+    execute: (context, input) => {
+        const target = resolveFormulaTarget(context, input);
+        if (!target || !input)
+            throw new Error("formula.insert requires a collapsed text selection and a formula.");
+        const formulaText = input.displayText ?? input.value;
+        const children = [...target.parent.children];
+        const replacement = [];
+        if (target.offset > 0) {
+            replacement.push({ ...target.node, text: target.node.text.slice(0, target.offset) });
+        }
+        replacement.push({
+            type: "formula",
+            value: input.value.trim(),
+            ...(formulaText !== input.value ? { displayText: formulaText } : {}),
+        });
+        const formulaIndex = target.index + (target.offset > 0 ? 1 : 0);
+        const trailingText = target.node.text.slice(target.offset);
+        replacement.push({ ...target.node, text: trailingText });
+        return {
+            id: "formula.insert",
+            source: "user",
+            operations: [{
+                    type: "replaceNode",
+                    path: target.parentPath,
+                    node: {
+                        ...target.parent,
+                        children: [
+                            ...children.slice(0, target.index),
+                            ...replacement,
+                            ...children.slice(target.index + 1),
+                        ],
+                    },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: {
+                type: "text",
+                anchor: { path: [...target.parentPath, formulaIndex + 1], offset: 0 },
+                focus: { path: [...target.parentPath, formulaIndex + 1], offset: 0 },
+            },
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+export const deleteFormula = createDeleteInlineAtomCommand("formula.delete", "formula");

package/dist/legacyCommands/inlineAtoms.d.ts

@@ -0,0 +1,7 @@
+import type { SmartCommand } from "../command.js";
+import { type Path, type SmartFormulaNode, type SmartInlineImageNode } from "../model.js";
+export type SmartInlineAtom = SmartFormulaNode | SmartInlineImageNode;
+export interface InlineAtomPathInput {
+    path: Path;
+}
+export declare const createDeleteInlineAtomCommand: (id: string, expectedType: SmartInlineAtom["type"]) => SmartCommand<InlineAtomPathInput>;

package/dist/legacyCommands/inlineAtoms.js

@@ -0,0 +1,58 @@
+import { getNodeAtPath, } from "../model.js";
+import { isSmartContainer } from "../tree.js";
+const resolveAtom = (context, input, expectedType) => {
+    if (!input?.path.length)
+        return null;
+    const atom = getNodeAtPath(context.document, input.path);
+    const parentPath = input.path.slice(0, -1);
+    const parent = getNodeAtPath(context.document, parentPath);
+    const index = input.path[input.path.length - 1];
+    if (atom?.type !== expectedType ||
+        !isSmartContainer(parent) ||
+        !["paragraph", "heading"].includes(String(parent.type)) ||
+        parent.children[index] !== atom)
+        return null;
+    return { parent, parentPath, index };
+};
+export const createDeleteInlineAtomCommand = (id, expectedType) => ({
+    id,
+    isEnabled: (context, input) => Boolean(resolveAtom(context, input, expectedType)),
+    execute: (context, input) => {
+        const target = resolveAtom(context, input, expectedType);
+        if (!target)
+            throw new Error(`${id} requires a valid ${expectedType} path.`);
+        const children = target.parent.children.filter((_, index) => index !== target.index);
+        let caretIndex = target.index;
+        if (!children.length) {
+            children.push({ type: "text", text: "" });
+            caretIndex = 0;
+        }
+        else if (children[caretIndex]?.type !== "text") {
+            if (caretIndex > 0 && children[caretIndex - 1]?.type === "text") {
+                caretIndex -= 1;
+            }
+            else {
+                children.splice(caretIndex, 0, { type: "text", text: "" });
+            }
+        }
+        const caret = children[caretIndex];
+        const offset = caret?.type === "text" && caretIndex < target.index ? caret.text.length : 0;
+        return {
+            id,
+            source: "user",
+            operations: [{
+                    type: "replaceNode",
+                    path: target.parentPath,
+                    node: { ...target.parent, children },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: {
+                type: "text",
+                anchor: { path: [...target.parentPath, caretIndex], offset },
+                focus: { path: [...target.parentPath, caretIndex], offset },
+            },
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+});

package/dist/legacyCommands/list.d.ts

@@ -0,0 +1,38 @@
+import { type Path, type LegacySmartDocument, type SmartListNode, type SmartListPreset } from "../model.js";
+import type { SmartCommand } from "../command.js";
+import type { LegacySmartSelection } from "../selection.js";
+import type { LegacySmartTransaction } from "../transaction.js";
+export type ListStyle = SmartListNode["style"];
+export interface ToggleTableCellListInput {
+    tablePath: Path;
+    row: number;
+    column: number;
+    blockIndexes: readonly number[];
+    style: ListStyle;
+    preset?: SmartListPreset;
+}
+export interface CommandResult {
+    document: LegacySmartDocument;
+    transaction: LegacySmartTransaction;
+}
+export interface ToggleListInput {
+    style: ListStyle;
+    preset?: SmartListPreset;
+    /**
+     * Toolbar list buttons use `containing-list` semantics by default, matching
+     * document editors that change the whole list when selection is inside it.
+     * Contextual item tools may request an exact selected run instead.
+     */
+    scope?: "containing-list" | "selected-items";
+    cascadeStyles?: boolean;
+    checklist?: boolean;
+    strikeCompleted?: boolean;
+}
+export declare const toggleList: SmartCommand<ToggleListInput>;
+export declare const indentListItems: SmartCommand<void>;
+export declare const outdentListItems: SmartCommand<void>;
+/**
+ * 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: LegacySmartDocument, selection: LegacySmartSelection, input: ToggleTableCellListInput) => CommandResult;