smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/legacyCommands/media.js

@@ -0,0 +1,205 @@
+import { getNodeAtPath, } from "../model.js";
+import { isSmartContainer } from "../tree.js";
+import { createDeleteInlineAtomCommand } from "./inlineAtoms.js";
+const blockTypes = new Set([
+    "paragraph", "heading", "list", "blockquote", "codeBlock", "image", "media", "table",
+]);
+const isBlock = (node) => Boolean(node) && typeof node === "object" &&
+    blockTypes.has(String(node.type));
+const canContainBlocks = (node) => {
+    const type = node?.type;
+    return type === "doc" || type === "listItem" || type === "blockquote" ||
+        type === "tableCell" || type === "tableHeaderCell";
+};
+const resolveInsertionPath = (context, explicit) => {
+    if (explicit) {
+        const parent = getNodeAtPath(context.document, explicit.slice(0, -1));
+        const index = explicit[explicit.length - 1];
+        return explicit.length > 0 && canContainBlocks(parent) && isSmartContainer(parent) &&
+            Number.isInteger(index) && index >= 0 && index <= parent.children.length
+            ? [...explicit]
+            : null;
+    }
+    if (context.selection.type === "all")
+        return [context.document.children.length];
+    let path;
+    if (context.selection.type === "node")
+        path = context.selection.path;
+    if (context.selection.type === "text")
+        path = context.selection.focus.path;
+    if (context.selection.type === "cell") {
+        path = [
+            ...context.selection.tablePath,
+            context.selection.start.row,
+            context.selection.start.column,
+        ];
+    }
+    if (!path)
+        return null;
+    for (let length = path.length; length > 0; length -= 1) {
+        const candidatePath = path.slice(0, length);
+        if (!isBlock(getNodeAtPath(context.document, candidatePath)))
+            continue;
+        const parent = getNodeAtPath(context.document, candidatePath.slice(0, -1));
+        if (!canContainBlocks(parent))
+            continue;
+        return [
+            ...candidatePath.slice(0, -1),
+            candidatePath[candidatePath.length - 1] + 1,
+        ];
+    }
+    const selected = getNodeAtPath(context.document, path);
+    if (canContainBlocks(selected) && isSmartContainer(selected)) {
+        return [...path, selected.children.length];
+    }
+    return null;
+};
+const insertBlockTransaction = (context, id, path, node) => ({
+    id,
+    source: "user",
+    operations: [{ type: "insertNode", path, node }],
+    selectionBefore: context.selection,
+    selectionAfter: { type: "node", path },
+    addToHistory: true,
+    timestamp: context.now?.() ?? Date.now(),
+});
+const validImageInput = (input) => Boolean(input?.src.trim()) &&
+    (input?.width === undefined || Number.isFinite(input.width) && input.width > 0) &&
+    (input?.height === undefined || Number.isFinite(input.height) && input.height > 0);
+export const insertImage = {
+    id: "image.insert",
+    isEnabled: (context, input) => validImageInput(input) && Boolean(resolveInsertionPath(context, input?.path)),
+    execute: (context, input) => {
+        const path = input && resolveInsertionPath(context, input.path);
+        if (!input || !validImageInput(input) || !path) {
+            throw new Error("image.insert requires a valid image and block insertion path.");
+        }
+        return insertBlockTransaction(context, "image.insert", path, {
+            type: "image",
+            src: input.src.trim(),
+            ...(input.alt ? { alt: input.alt } : {}),
+            ...(input.title ? { title: input.title } : {}),
+            ...(input.width ? { width: input.width } : {}),
+            ...(input.height ? { height: input.height } : {}),
+        });
+    },
+};
+const resolveInlineImageTarget = (context) => {
+    if (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) ||
+        !["paragraph", "heading"].includes(String(parent.type)) ||
+        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 insertInlineImage = {
+    id: "image.insert-inline",
+    isEnabled: (context, input) => validImageInput(input) && Boolean(resolveInlineImageTarget(context)),
+    execute: (context, input) => {
+        const target = resolveInlineImageTarget(context);
+        if (!input || !validImageInput(input) || !target) {
+            throw new Error("image.insert-inline requires a collapsed selection in paragraph or heading text.");
+        }
+        const image = {
+            type: "inlineImage",
+            src: input.src.trim(),
+            ...(input.alt ? { alt: input.alt } : {}),
+            ...(input.title ? { title: input.title } : {}),
+            ...(input.width ? { width: input.width } : {}),
+            ...(input.height ? { height: input.height } : {}),
+        };
+        const replacement = [];
+        if (target.offset > 0) {
+            replacement.push({ ...target.node, text: target.node.text.slice(0, target.offset) });
+        }
+        replacement.push(image);
+        replacement.push({ ...target.node, text: target.node.text.slice(target.offset) });
+        const imageIndex = target.index + (target.offset > 0 ? 1 : 0);
+        return {
+            id: "image.insert-inline",
+            source: "user",
+            operations: [{
+                    type: "replaceNode",
+                    path: target.parentPath,
+                    node: {
+                        ...target.parent,
+                        children: [
+                            ...target.parent.children.slice(0, target.index),
+                            ...replacement,
+                            ...target.parent.children.slice(target.index + 1),
+                        ],
+                    },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: {
+                type: "text",
+                anchor: { path: [...target.parentPath, imageIndex + 1], offset: 0 },
+                focus: { path: [...target.parentPath, imageIndex + 1], offset: 0 },
+            },
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+export const deleteInlineImage = createDeleteInlineAtomCommand("image.delete-inline", "inlineImage");
+export const updateInlineImage = {
+    id: "image.update-inline",
+    isEnabled: (context, input) => {
+        const node = input && getNodeAtPath(context.document, input.path);
+        return Boolean(node && node.type === "inlineImage" &&
+            (input?.width === undefined || Number.isFinite(input.width) && input.width > 0) &&
+            (input?.height === undefined || Number.isFinite(input.height) && input.height > 0));
+    },
+    execute: (context, input) => {
+        if (!input || !updateInlineImage.isEnabled(context, input)) {
+            throw new Error("image.update-inline requires a valid inline image path and dimensions.");
+        }
+        return {
+            id: "image.update-inline",
+            source: "user",
+            operations: [{
+                    type: "setNodeAttrs",
+                    path: input.path,
+                    attrs: {
+                        alt: input.alt,
+                        title: input.title,
+                        width: input.width,
+                        height: input.height,
+                    },
+                }],
+            selectionBefore: context.selection,
+            selectionAfter: context.selection,
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+const validMediaInput = (input) => Boolean(input?.src.trim()) && Boolean(input && ["audio", "video", "file"].includes(input.mediaType));
+export const insertMedia = {
+    id: "media.insert",
+    isEnabled: (context, input) => validMediaInput(input) && Boolean(resolveInsertionPath(context, input?.path)),
+    execute: (context, input) => {
+        const path = input && resolveInsertionPath(context, input.path);
+        if (!input || !validMediaInput(input) || !path) {
+            throw new Error("media.insert requires valid media and a block insertion path.");
+        }
+        return insertBlockTransaction(context, "media.insert", path, {
+            type: "media",
+            src: input.src.trim(),
+            mediaType: input.mediaType,
+            ...(input.title ? { title: input.title } : {}),
+            ...(input.mimeType ? { mimeType: input.mimeType } : {}),
+        });
+    },
+};

package/dist/legacyCommands/move.d.ts

@@ -0,0 +1,14 @@
+import type { SmartCommand } from "../command.js";
+import type { Path } from "../model.js";
+export interface MoveBlocksInput {
+    parentPath: Path;
+    blockIndexes: readonly number[];
+    direction: "up" | "down";
+}
+export interface IndentBlocksInput {
+    parentPath: Path;
+    blockIndexes: readonly number[];
+    direction: "indent" | "outdent";
+}
+export declare const moveBlocks: SmartCommand<MoveBlocksInput>;
+export declare const indentBlocks: SmartCommand<IndentBlocksInput>;

package/dist/legacyCommands/move.js

@@ -0,0 +1,91 @@
+import { getNodeAtTreePath, isSmartContainer } from "../tree.js";
+const normalizedIndexes = (indexes) => {
+    const result = [...new Set(indexes)].sort((left, right) => left - right);
+    if (!result.length || result.some((index) => !Number.isInteger(index) || index < 0))
+        return undefined;
+    if (result.some((index, position) => position > 0 && index !== result[position - 1] + 1))
+        return undefined;
+    return result;
+};
+const resolveSiblingRange = (context, parentPath, indexes) => {
+    const normalized = normalizedIndexes(indexes);
+    if (!normalized)
+        return undefined;
+    try {
+        const parent = getNodeAtTreePath(context.document, parentPath);
+        if (!isSmartContainer(parent) || normalized[normalized.length - 1] >= parent.children.length)
+            return undefined;
+        return { parent, indexes: normalized };
+    }
+    catch {
+        return undefined;
+    }
+};
+export const moveBlocks = {
+    id: "block.move",
+    isEnabled: (context, input) => {
+        if (!input)
+            return false;
+        const range = resolveSiblingRange(context, input.parentPath, input.blockIndexes);
+        if (!range)
+            return false;
+        return input.direction === "up"
+            ? range.indexes[0] > 0
+            : range.indexes[range.indexes.length - 1] < range.parent.children.length - 1;
+    },
+    execute: (context, input) => {
+        if (!input || !moveBlocks.isEnabled(context, input)) {
+            throw new Error("block.move requires a movable contiguous sibling range.");
+        }
+        const indexes = normalizedIndexes(input.blockIndexes);
+        const first = indexes[0];
+        const last = indexes[indexes.length - 1];
+        return {
+            id: "move-blocks",
+            source: "user",
+            operations: input.direction === "up"
+                ? [{ type: "moveNode", from: [...input.parentPath, first - 1], to: [...input.parentPath, last + 1] }]
+                : [{ type: "moveNode", from: [...input.parentPath, last + 1], to: [...input.parentPath, first] }],
+            selectionBefore: context.selection,
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};
+export const indentBlocks = {
+    id: "block.indent",
+    isEnabled: (context, input) => {
+        if (!input)
+            return false;
+        const range = resolveSiblingRange(context, input.parentPath, input.blockIndexes);
+        if (!range)
+            return false;
+        return range.indexes.some((index) => {
+            const indent = Number(range.parent.children[index].indent) || 0;
+            return input.direction === "indent" ? indent < 10 : indent > 0;
+        });
+    },
+    execute: (context, input) => {
+        if (!input || !indentBlocks.isEnabled(context, input)) {
+            throw new Error("block.indent requires a sibling range whose indentation can change.");
+        }
+        const range = resolveSiblingRange(context, input.parentPath, input.blockIndexes);
+        return {
+            id: "indent-blocks",
+            source: "user",
+            operations: range.indexes.flatMap((index) => {
+                const indent = Number(range.parent.children[index].indent) || 0;
+                const nextIndent = input.direction === "indent"
+                    ? Math.min(indent + 1, 10)
+                    : Math.max(indent - 1, 0);
+                return nextIndent === indent
+                    ? []
+                    : [{ type: "setNodeAttrs", path: [...input.parentPath, index], attrs: { indent: nextIndent || undefined } }];
+            }),
+            selectionBefore: context.selection,
+            selectionAfter: context.selection,
+            addToHistory: true,
+            timestamp: context.now?.() ?? Date.now(),
+        };
+    },
+};

package/dist/legacyCommands/table.d.ts

@@ -0,0 +1,91 @@
+import type { SmartCommand } from "../command.js";
+import { type Path } from "../model.js";
+export interface InsertTableInput {
+    path: Path;
+    rows: number;
+    columns: number;
+    headerRow?: boolean;
+}
+export declare const insertTable: SmartCommand<InsertTableInput>;
+export interface RemoveTableInput {
+    tablePath: Path;
+}
+export declare const removeTable: SmartCommand<RemoveTableInput>;
+export interface TableHeaderInput {
+    tablePath: Path;
+    row: number;
+    column: number;
+}
+export type TableHeaderScope = "cell" | "row" | "column";
+export declare const toggleTableHeaderCell: SmartCommand<TableHeaderInput>;
+export declare const toggleTableHeaderRow: SmartCommand<TableHeaderInput>;
+export declare const toggleTableHeaderColumn: SmartCommand<TableHeaderInput>;
+export interface SetTableCellStyleInput {
+    tablePath: Path;
+    start: {
+        row: number;
+        column: number;
+    };
+    end?: {
+        row: number;
+        column: number;
+    };
+    backgroundColor?: string | null;
+    textColor?: string | null;
+}
+export declare const setTableCellStyle: SmartCommand<SetTableCellStyleInput>;
+export interface ToggleTableCellBorderInput {
+    tablePath: Path;
+    start: {
+        row: number;
+        column: number;
+    };
+    end?: {
+        row: number;
+        column: number;
+    };
+    visibleBorder?: string;
+}
+export declare const toggleTableCellBorder: SmartCommand<ToggleTableCellBorderInput>;
+export interface SetTableColumnWidthInput {
+    tablePath: Path;
+    index: number;
+    widthPx: number;
+}
+export declare const setTableColumnWidth: SmartCommand<SetTableColumnWidthInput>;
+export interface SetTableRowHeightInput {
+    tablePath: Path;
+    index: number;
+    heightPx: number;
+}
+export declare const setTableRowHeight: SmartCommand<SetTableRowHeightInput>;
+export interface TableRowInput {
+    tablePath: Path;
+    index: number;
+}
+export declare const addTableRow: SmartCommand<TableRowInput>;
+export declare const removeTableRow: SmartCommand<TableRowInput>;
+export interface TableColumnInput {
+    tablePath: Path;
+    index: number;
+}
+export declare const addTableColumn: SmartCommand<TableColumnInput>;
+export declare const removeTableColumn: SmartCommand<TableColumnInput>;
+export interface MergeTableCellsInput {
+    tablePath: Path;
+    start: {
+        row: number;
+        column: number;
+    };
+    end: {
+        row: number;
+        column: number;
+    };
+}
+export declare const mergeTableCells: SmartCommand<MergeTableCellsInput>;
+export interface SplitTableCellInput {
+    tablePath: Path;
+    row: number;
+    column: number;
+}
+export declare const splitTableCell: SmartCommand<SplitTableCellInput>;