smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/preset.js

@@ -0,0 +1,40 @@
+import { alignmentPlugin } from "./plugins/alignment.js";
+import { basicFormattingPlugin } from "./plugins/basicFormatting.js";
+import { blockquotePlugin } from "./plugins/blockquote.js";
+import { blockTypePlugin } from "./plugins/blockType.js";
+import { checklistPlugin } from "./plugins/checklist.js";
+import { codeBlockPlugin } from "./plugins/codeBlock.js";
+import { formulaPlugin } from "./plugins/formula.js";
+import { listPlugin } from "./plugins/list.js";
+import { mediaPlugin } from "./plugins/media.js";
+import { movePlugin } from "./plugins/move.js";
+import { tablePlugin } from "./plugins/table.js";
+const features = {
+    basicFormatting: basicFormattingPlugin,
+    blockType: blockTypePlugin,
+    alignment: alignmentPlugin,
+    list: listPlugin,
+    checklist: checklistPlugin,
+    blockquote: blockquotePlugin,
+    codeBlock: codeBlockPlugin,
+    table: tablePlugin,
+    media: mediaPlugin,
+    formula: formulaPlugin,
+    move: movePlugin,
+};
+const featureOrder = Object.keys(features);
+/**
+ * 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 const createCorePlugins = (config = {}) => {
+    const enabled = (id) => config[id] !== false;
+    return featureOrder
+        .filter((id) => enabled(id))
+        .filter((id) => id !== "checklist" || enabled("list"))
+        .map((id) => features[id]);
+};
+export const corePlugins = createCorePlugins();

package/dist/schema.d.ts

@@ -0,0 +1,22 @@
+import { type Path, type LegacySmartDocument } from "./model.js";
+export interface SchemaIssue {
+    path: Path;
+    code: string;
+    message: string;
+}
+export interface SchemaValidationResult {
+    valid: boolean;
+    issues: SchemaIssue[];
+}
+export interface SmartSchemaExtension {
+    id: string;
+    normalize?: (document: LegacySmartDocument) => LegacySmartDocument;
+    validate?: (document: LegacySmartDocument) => SchemaIssue[];
+}
+export interface LegacySmartSchema {
+    extensions: readonly SmartSchemaExtension[];
+}
+export declare const createSmartSchema: (extensions?: readonly SmartSchemaExtension[]) => LegacySmartSchema;
+export declare const defaultSmartSchema: LegacySmartSchema;
+export declare const normalizeSmartDocument: (document: LegacySmartDocument, schema?: LegacySmartSchema) => LegacySmartDocument;
+export declare const validateSmartDocument: (document: LegacySmartDocument, schema?: LegacySmartSchema) => SchemaValidationResult;

package/dist/schema.js

@@ -0,0 +1,333 @@
+import { paragraph, } from "./model.js";
+import { isSmartListPreset } from "./listPresets.js";
+export const createSmartSchema = (extensions = []) => {
+    const ids = new Set();
+    extensions.forEach((extension) => {
+        if (!extension.id.trim())
+            throw new Error("Schema extension id cannot be empty.");
+        if (ids.has(extension.id))
+            throw new Error(`Duplicate schema extension id "${extension.id}".`);
+        ids.add(extension.id);
+    });
+    return { extensions: [...extensions] };
+};
+export const defaultSmartSchema = createSmartSchema();
+const listStyles = new Set([
+    "disc",
+    "circle",
+    "square",
+    "decimal",
+    "decimal-leading-zero",
+    "lower-alpha",
+    "upper-alpha",
+    "lower-roman",
+    "upper-roman",
+]);
+const markKey = (mark) => JSON.stringify(mark);
+const normalizedIndent = (value) => Number.isInteger(value) && (value || 0) > 0 ? Math.min(value || 0, 10) : undefined;
+const normalizeMarks = (marks) => {
+    if (!marks?.length)
+        return undefined;
+    const seen = new Set();
+    const normalized = marks.filter((mark) => {
+        const key = markKey(mark);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return normalized.length ? normalized : undefined;
+};
+const normalizeText = (node) => {
+    const marks = normalizeMarks(node.marks);
+    return marks ? { type: "text", text: String(node.text ?? ""), marks } : { type: "text", text: String(node.text ?? "") };
+};
+const normalizeInlineImage = (node) => {
+    const width = Number.isFinite(node.width) && (node.width || 0) > 0 ? node.width : undefined;
+    const height = Number.isFinite(node.height) && (node.height || 0) > 0 ? node.height : undefined;
+    return {
+        type: "inlineImage",
+        src: String(node.src ?? ""),
+        ...(node.alt ? { alt: String(node.alt) } : {}),
+        ...(node.title ? { title: String(node.title) } : {}),
+        ...(width ? { width } : {}),
+        ...(height ? { height } : {}),
+    };
+};
+const normalizeInlineChildren = (children) => {
+    const normalized = (children || []).map((node) => {
+        if (node.type === "text")
+            return normalizeText(node);
+        if (node.type === "formula") {
+            return {
+                type: "formula",
+                value: String(node.value ?? ""),
+                ...(node.displayText ? { displayText: String(node.displayText) } : {}),
+            };
+        }
+        return normalizeInlineImage(node);
+    });
+    return normalized.length ? normalized : [{ type: "text", text: "" }];
+};
+const normalizeListItem = (item) => {
+    const children = (item.children || []).map(normalizeBlock);
+    return {
+        type: "listItem",
+        ...(item.alignment ? { alignment: item.alignment } : {}),
+        ...(typeof item.checked === "boolean" ? { checked: item.checked } : {}),
+        children: children.length ? children : [paragraph()],
+    };
+};
+const normalizeCell = (cell) => {
+    const children = (cell.children || []).map(normalizeBlock);
+    const colspan = Number.isInteger(cell.colspan) && (cell.colspan || 0) > 1 ? cell.colspan : undefined;
+    const rowspan = Number.isInteger(cell.rowspan) && (cell.rowspan || 0) > 1 ? cell.rowspan : undefined;
+    return {
+        type: cell.type === "tableHeaderCell" ? "tableHeaderCell" : "tableCell",
+        ...(colspan ? { colspan } : {}),
+        ...(rowspan ? { rowspan } : {}),
+        ...(cell.backgroundColor ? { backgroundColor: String(cell.backgroundColor) } : {}),
+        ...(cell.textColor ? { textColor: String(cell.textColor) } : {}),
+        ...(cell.border ? { border: String(cell.border) } : {}),
+        children: children.length ? children : [paragraph()],
+    };
+};
+const normalizeBlock = (block) => {
+    if (block.type === "paragraph") {
+        return {
+            type: "paragraph",
+            ...(block.alignment ? { alignment: block.alignment } : {}),
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            children: normalizeInlineChildren(block.children),
+        };
+    }
+    if (block.type === "heading") {
+        const level = Math.max(1, Math.min(6, Number(block.level) || 1));
+        return {
+            type: "heading",
+            level,
+            ...(block.alignment ? { alignment: block.alignment } : {}),
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            children: normalizeInlineChildren(block.children),
+        };
+    }
+    if (block.type === "list") {
+        const children = (block.children || []).map(normalizeListItem);
+        return {
+            type: "list",
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            style: listStyles.has(block.style) ? block.style : "disc",
+            ...(isSmartListPreset(block.preset) ? { preset: block.preset } : {}),
+            ...(block.checklist ? { checklist: true } : {}),
+            ...(block.checklist && block.strikeCompleted ? { strikeCompleted: true } : {}),
+            children: children.length ? children : [normalizeListItem({ type: "listItem", children: [] })],
+        };
+    }
+    if (block.type === "blockquote") {
+        const children = (block.children || []).map(normalizeBlock);
+        return {
+            type: "blockquote",
+            ...(block.alignment ? { alignment: block.alignment } : {}),
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            children: children.length ? children : [paragraph()],
+        };
+    }
+    if (block.type === "codeBlock") {
+        return {
+            type: "codeBlock",
+            ...(block.alignment ? { alignment: block.alignment } : {}),
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            text: String(block.text ?? ""),
+            ...(block.language ? { language: block.language } : {}),
+        };
+    }
+    if (block.type === "image") {
+        const width = Number.isFinite(block.width) && (block.width || 0) > 0 ? block.width : undefined;
+        const height = Number.isFinite(block.height) && (block.height || 0) > 0 ? block.height : undefined;
+        return {
+            type: "image",
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            src: String(block.src ?? ""),
+            ...(block.alt ? { alt: String(block.alt) } : {}),
+            ...(block.title ? { title: String(block.title) } : {}),
+            ...(width ? { width } : {}),
+            ...(height ? { height } : {}),
+        };
+    }
+    if (block.type === "media") {
+        return {
+            type: "media",
+            ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+            src: String(block.src ?? ""),
+            mediaType: block.mediaType === "audio" || block.mediaType === "file" ? block.mediaType : "video",
+            ...(block.title ? { title: String(block.title) } : {}),
+            ...(block.mimeType ? { mimeType: String(block.mimeType) } : {}),
+        };
+    }
+    const rows = (block.children || []).map((row) => {
+        const cells = (row.children || []).map(normalizeCell);
+        return {
+            type: "tableRow",
+            ...(Number.isFinite(row.heightPx) && (row.heightPx || 0) >= 30
+                ? { heightPx: Number(row.heightPx) }
+                : {}),
+            children: cells,
+        };
+    });
+    const normalizedRows = rows.map((row, rowIndex) => {
+        if (row.children.length)
+            return row;
+        const coveredByRowspan = rows.slice(0, rowIndex).some((previous, previousIndex) => previous.children.some((cell) => (cell.rowspan || 1) > rowIndex - previousIndex));
+        return coveredByRowspan
+            ? row
+            : { ...row, children: [normalizeCell({ type: "tableCell", children: [] })] };
+    });
+    return {
+        type: "table",
+        ...(normalizedIndent(block.indent) ? { indent: normalizedIndent(block.indent) } : {}),
+        ...(block.columnWidths?.length
+            ? { columnWidths: block.columnWidths.map((width) => Math.max(60, Number(width) || 60)) }
+            : {}),
+        children: normalizedRows.length
+            ? normalizedRows
+            : [{ type: "tableRow", children: [normalizeCell({ type: "tableCell", children: [] })] }],
+    };
+};
+const normalizeBuiltInDocument = (document) => {
+    const children = (document.children || []).map(normalizeBlock);
+    return { type: "doc", children: children.length ? children : [paragraph()] };
+};
+export const normalizeSmartDocument = (document, schema = defaultSmartSchema) => schema.extensions.reduce((current, extension) => normalizeBuiltInDocument(extension.normalize ? extension.normalize(current) : current), normalizeBuiltInDocument(document));
+const issue = (issues, path, code, message) => {
+    issues.push({ path: [...path], code, message });
+};
+const validateTextChildren = (children, path, issues) => {
+    if (!children.length)
+        issue(issues, path, "empty-inline-container", "Inline containers require at least one inline node.");
+    children.forEach((node, index) => {
+        const nodePath = [...path, index];
+        if (node.type === "formula") {
+            if (!node.value)
+                issue(issues, nodePath, "empty-formula", "Formula atoms require a value.");
+            return;
+        }
+        if (node.type === "inlineImage") {
+            if (!node.src)
+                issue(issues, nodePath, "missing-inline-image-source", "Inline images require a source.");
+            if (node.width !== undefined && (!Number.isFinite(node.width) || node.width <= 0)) {
+                issue(issues, nodePath, "invalid-inline-image-width", "Inline image width must be positive.");
+            }
+            if (node.height !== undefined && (!Number.isFinite(node.height) || node.height <= 0)) {
+                issue(issues, nodePath, "invalid-inline-image-height", "Inline image height must be positive.");
+            }
+            return;
+        }
+        if (typeof node.text !== "string") {
+            issue(issues, nodePath, "invalid-text-node", "Text nodes require string content.");
+        }
+        const keys = (node.marks || []).map(markKey);
+        if (new Set(keys).size !== keys.length) {
+            issue(issues, nodePath, "duplicate-mark", "A text node cannot contain duplicate marks.");
+        }
+    });
+};
+const validateBlock = (block, path, issues) => {
+    if (block.type === "paragraph" || block.type === "heading") {
+        if (block.type === "heading" && (!Number.isInteger(block.level) || block.level < 1 || block.level > 6)) {
+            issue(issues, path, "invalid-heading-level", "Heading level must be between 1 and 6.");
+        }
+        validateTextChildren(block.children, path, issues);
+        return;
+    }
+    if (block.type === "list") {
+        if (!listStyles.has(block.style))
+            issue(issues, path, "invalid-list-style", "List style is not supported.");
+        if (block.preset !== undefined && !isSmartListPreset(block.preset))
+            issue(issues, path, "invalid-list-preset", "List preset is not supported.");
+        if (!block.children.length)
+            issue(issues, path, "empty-list", "Lists require at least one list item.");
+        block.children.forEach((item, itemIndex) => {
+            const itemPath = [...path, itemIndex];
+            if (item.type !== "listItem")
+                issue(issues, itemPath, "invalid-list-child", "Lists may only contain list items.");
+            if (!item.children.length)
+                issue(issues, itemPath, "empty-list-item", "List items require block content.");
+            item.children.forEach((child, childIndex) => validateBlock(child, [...itemPath, childIndex], issues));
+        });
+        return;
+    }
+    if (block.type === "blockquote") {
+        if (!block.children.length)
+            issue(issues, path, "empty-blockquote", "Blockquotes require block content.");
+        block.children.forEach((child, index) => validateBlock(child, [...path, index], issues));
+        return;
+    }
+    if (block.type === "codeBlock") {
+        if (typeof block.text !== "string")
+            issue(issues, path, "invalid-code-text", "Code block text must be a string.");
+        return;
+    }
+    if (block.type === "image") {
+        if (!block.src)
+            issue(issues, path, "missing-image-source", "Images require a source.");
+        if (block.width !== undefined && (!Number.isFinite(block.width) || block.width <= 0)) {
+            issue(issues, path, "invalid-image-width", "Image width must be positive.");
+        }
+        if (block.height !== undefined && (!Number.isFinite(block.height) || block.height <= 0)) {
+            issue(issues, path, "invalid-image-height", "Image height must be positive.");
+        }
+        return;
+    }
+    if (block.type === "media") {
+        if (!block.src)
+            issue(issues, path, "missing-media-source", "Media requires a source.");
+        if (!["audio", "video", "file"].includes(block.mediaType)) {
+            issue(issues, path, "invalid-media-type", "Media type is not supported.");
+        }
+        return;
+    }
+    if (block.type === "table") {
+        if (!block.children.length)
+            issue(issues, path, "empty-table", "Tables require at least one row.");
+        block.children.forEach((row, rowIndex) => {
+            const rowPath = [...path, rowIndex];
+            if (row.type !== "tableRow")
+                issue(issues, rowPath, "invalid-table-child", "Tables may only contain rows.");
+            const coveredByRowspan = block.children.slice(0, rowIndex).some((previous, previousIndex) => previous.children.some((cell) => (cell.rowspan || 1) > rowIndex - previousIndex));
+            if (!row.children.length && !coveredByRowspan) {
+                issue(issues, rowPath, "empty-table-row", "Table rows require a cell or coverage from a rowspan.");
+            }
+            row.children.forEach((cell, cellIndex) => {
+                const cellPath = [...rowPath, cellIndex];
+                if (cell.type !== "tableCell" && cell.type !== "tableHeaderCell") {
+                    issue(issues, cellPath, "invalid-row-child", "Table rows may only contain cells.");
+                }
+                if (!cell.children.length)
+                    issue(issues, cellPath, "empty-table-cell", "Table cells require block content.");
+                if (cell.colspan !== undefined && (!Number.isInteger(cell.colspan) || cell.colspan < 1)) {
+                    issue(issues, cellPath, "invalid-colspan", "Cell colspan must be a positive integer.");
+                }
+                if (cell.rowspan !== undefined && (!Number.isInteger(cell.rowspan) || cell.rowspan < 1)) {
+                    issue(issues, cellPath, "invalid-rowspan", "Cell rowspan must be a positive integer.");
+                }
+                cell.children.forEach((child, childIndex) => validateBlock(child, [...cellPath, childIndex], issues));
+            });
+        });
+    }
+};
+export const validateSmartDocument = (document, schema = defaultSmartSchema) => {
+    const issues = [];
+    if (document.type !== "doc")
+        issue(issues, [], "invalid-root", "The document root must have type doc.");
+    if (!Array.isArray(document.children) || !document.children.length) {
+        issue(issues, [], "empty-document", "The document requires at least one block.");
+    }
+    else {
+        document.children.forEach((block, index) => validateBlock(block, [index], issues));
+    }
+    schema.extensions.forEach((extension) => {
+        if (extension.validate)
+            issues.push(...extension.validate(document));
+    });
+    return { valid: issues.length === 0, issues };
+};

package/dist/security/urlPolicy.d.ts

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

package/dist/security/urlPolicy.js

@@ -1,69 +1,3 @@
-const allowedProtocols = new Set(["http:", "https:", "mailto:", "tel:"]);
-const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-const bareDomainPattern = /^(?:www\.)?[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+(?:[/?#][^\s]*)?$/;
-const phonePattern = /^\+?[\d\s().-]{7,}$/;
-const normalizePhone = (value) => {
-    const hasLeadingPlus = value.trim().startsWith("+");
-    const digits = value.replace(/[^\d]/g, "");
-    if (digits.length < 7)
-        return null;
-    return `${hasLeadingPlus ? "+" : ""}${digits}`;
-};
-const normalizeMailto = (value) => {
-    const email = value.slice("mailto:".length).trim();
-    return emailPattern.test(email) ? `mailto:${email}` : null;
-};
-const normalizeTel = (value) => {
-    const phone = normalizePhone(value.slice("tel:".length));
-    return phone ? `tel:${phone}` : null;
-};
-export const normalizeLinkInput = (input) => {
-    const trimmed = input?.trim() || "";
-    if (!trimmed)
-        return { kind: "invalid", href: null, input: "" };
-    if (/^mailto:/i.test(trimmed)) {
-        const href = normalizeMailto(trimmed);
-        return { kind: href ? "email" : "invalid", href, input: trimmed };
-    }
-    if (/^tel:/i.test(trimmed)) {
-        const href = normalizeTel(trimmed);
-        return { kind: href ? "phone" : "invalid", href, input: trimmed };
-    }
-    if (emailPattern.test(trimmed)) {
-        return { kind: "email", href: `mailto:${trimmed}`, input: trimmed };
-    }
-    const phone = normalizePhone(trimmed);
-    if (phone && (trimmed.startsWith("+") || phonePattern.test(trimmed))) {
-        return { kind: "phone", href: `tel:${phone}`, input: trimmed };
-    }
-    if (/^#[A-Za-z][\w:.-]*$/.test(trimmed)) {
-        return { kind: "anchor", href: trimmed, input: trimmed };
-    }
-    if (bareDomainPattern.test(trimmed)) {
-        return { kind: "url", href: `https://${trimmed}`, input: trimmed };
-    }
-    try {
-        const parsed = new URL(trimmed);
-        return {
-            kind: allowedProtocols.has(parsed.protocol) ? "url" : "invalid",
-            href: allowedProtocols.has(parsed.protocol) ? trimmed : null,
-            input: trimmed,
-        };
-    }
-    catch {
-        return { kind: "invalid", href: null, input: trimmed };
-    }
-};
-export const sanitizeLinkHref = (href) => {
-    return normalizeLinkInput(href).href;
-};
-export const sanitizeLinkTarget = (target) => {
-    const trimmed = target?.trim();
-    return trimmed || undefined;
-};
-export const sanitizeLinkAttrs = (input) => {
-    const href = sanitizeLinkHref(input.href);
-    if (!href)
-        return null;
-    return { href, target: sanitizeLinkTarget(input.target) };
-};
+// Legacy compatibility entry point. The canonical implementation lives inside
+// the foundation boundary so mark commands do not depend on root contracts.
+export * from "../foundation/security/urlPolicy.js";

package/dist/selection.d.ts

@@ -27,4 +27,4 @@ export interface SmartCellSelection {
 export interface SmartAllSelection {
     type: "all";
 }
-export type SmartSelection = SmartTextSelection | SmartNodeSelection | SmartCellSelection | SmartAllSelection;
+export type LegacySmartSelection = SmartTextSelection | SmartNodeSelection | SmartCellSelection | SmartAllSelection;

package/dist/selectionMapping.d.ts

@@ -0,0 +1,4 @@
+import type { LegacySmartDocument } from "./model.js";
+import type { LegacySmartSelection } from "./selection.js";
+import type { LegacySmartOperation } from "./transaction.js";
+export declare const mapSelectionThroughOperation: (selection: LegacySmartSelection, operation: LegacySmartOperation, documentBefore: LegacySmartDocument) => LegacySmartSelection;