smartrte-react 0.3.5 → 1.0.0-beta.1

package/dist/versionProvider.d.ts

@@ -0,0 +1,29 @@
+import type { DocumentVersion } from "smartrte-core/foundation";
+/**
+ * The listing-cheap projection of a `DocumentVersion` - a host's backend
+ * shouldn't have to ship every saved version's full document body just to
+ * render a history list. Mirrors `MediaProvider.search` returning
+ * `MediaItem` (metadata) rather than raw asset bytes.
+ */
+export interface VersionListEntry {
+    readonly id: string;
+    readonly label?: string;
+    readonly createdAt: number;
+    readonly authorId?: string;
+}
+/**
+ * Host-owned version-storage boundary, mirroring `MediaProvider`'s shape
+ * and its "the editor never persists anything itself" contract: the host
+ * backend is the source of truth, and `save`/`list`/`load`/`remove` are
+ * the entire boundary. There is deliberately no shipped default
+ * implementation, exactly like `MediaProvider` - when a host doesn't
+ * supply one, the version-history feature is simply unavailable, the same
+ * way the media toolbar buttons are disabled when `mediaProvider` is
+ * absent.
+ */
+export interface VersionProvider {
+    save(version: DocumentVersion): Promise<VersionListEntry>;
+    list(): Promise<readonly VersionListEntry[]>;
+    load(id: string): Promise<DocumentVersion>;
+    remove(id: string): Promise<void>;
+}

package/dist/versionProvider.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,15 +1,26 @@
 {
   "name": "smartrte-react",
-  "version": "0.3.5",
+  "version": "1.0.0-beta.1",
   "description": "A powerful, feature-rich Rich Text Editor for React with support for tables, mathematical formulas (LaTeX/KaTeX), and media management",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./standalone/classic-editor-embed": {
+      "types": "./dist/standalone/classic-editor-embed.d.ts",
+      "import": "./dist/standalone/classic-editor-embed.js"
+    }
+  },
   "files": [
     "dist",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
+    "!dist/test-harness/**",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -41,16 +52,6 @@
   },
   "author": "Smart RTE Contributors",
   "license": "MIT",
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build",
-    "dev": "pnpm build",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run --passWithNoTests",
-    "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build",
-    "e2e": "playwright test --pass-with-no-tests"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -60,16 +61,18 @@
     "react-dom": ">=18"
   },
   "devDependencies": {
+    "@axe-core/playwright": "^4.12.1",
     "@playwright/test": "^1.48.2",
     "@storybook/addon-essentials": "^8.6.14",
     "@storybook/react": "^8.6.14",
     "@storybook/react-vite": "^8.6.14",
+    "@types/node": "^22",
     "@types/pdfjs-dist": "^2.10.377",
     "@types/react": "^18.3.4",
     "@types/react-dom": "^18.3.0",
+    "jsdom": "^25.0.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "jsdom": "^25.0.1",
     "storybook": "^8.6.14",
     "typescript": "^5.6.2",
     "vite": "^5.4.8",
@@ -77,8 +80,19 @@
   },
   "dependencies": {
     "jszip": "^3.10.1",
+    "katex": "^0.18.4",
+    "lucide-react": "^1.35.0",
     "mammoth": "^1.11.0",
     "pdfjs-dist": "^5.4.530",
-    "smartrte-core": "^0.2.1"
+    "smartrte-core": "^1.0.0-beta.1"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "dev": "pnpm build",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "e2e": "pnpm --filter smartrte-core build && pnpm build && playwright test --pass-with-no-tests"
   }
-}
+}

package/dist/adapters/canonicalInlineCommandBridge.d.ts

@@ -1,15 +0,0 @@
-import { inlineToolDeclarations, type Attrs, type SmartMark } from "smartrte-core";
-export type CanonicalInlineToolId = typeof inlineToolDeclarations[number]["id"];
-export type CanonicalInlineIntent = "apply" | "remove" | "toggle" | "setAttrs" | "clearAll" | "editLink";
-export interface CanonicalInlineExecution {
-    readonly changed: boolean;
-    readonly operations: number;
-    readonly coverage: "all" | "partial" | "none";
-}
-export declare const executeCanonicalInlineTool: (root: HTMLElement, id: CanonicalInlineToolId, intent?: CanonicalInlineIntent, attrs?: Attrs) => CanonicalInlineExecution;
-/** Consumes adapter stored marks for ordinary text input. Composition remains
- * owned by the canonical surface; atom-aware composition is explicitly Phase 7. */
-export declare const installCanonicalInlineStoredMarkInput: (root: HTMLElement) => (() => void);
-export declare const canonicalInlineStoredMarks: (root: HTMLElement) => readonly SmartMark[];
-export declare const hasCanonicalInlineStoredMarkOverride: (root: HTMLElement) => boolean;
-export declare const describeCanonicalInlineCoverage: (root: HTMLElement) => Readonly<Record<string, "all" | "partial">>;

package/dist/adapters/canonicalInlineCommandBridge.js

@@ -1,269 +0,0 @@
-import { applyMarkCommand, applyOperations, clearAllMarksCommand, createFoundationEditor, createNodeId, createScopeIndex, editLinkCommand, executeMarkTool, foundationSchema, inlineToolDeclarations, parseCanonicalListHtml, removeLinkCommand, removeMarkCommand, serializeCanonicalListHtml, toggleMarkCommand, } from "smartrte-core";
-const storedMarks = new WeakMap();
-const ownerSelector = "p,h1,h2,h3,h4,h5,h6";
-const ownerId = (owner) => {
-    var _a;
-    (_a = owner.dataset).smartId || (_a.smartId = createNodeId());
-    return owner.dataset.smartId;
-};
-const contentWidth = (node) => {
-    if (node.nodeType === node.TEXT_NODE)
-        return node.nodeValue?.length || 0;
-    if (!(node instanceof HTMLElement))
-        return [...node.childNodes].reduce((sum, child) => sum + contentWidth(child), 0);
-    if (node.closest("[data-smart-ui]"))
-        return 0;
-    if (node.matches("br,[data-smart-atomic='true']"))
-        return 1;
-    return [...node.childNodes].reduce((sum, child) => sum + contentWidth(child), 0);
-};
-const pointInOwner = (root, node, offset) => {
-    const element = node instanceof HTMLElement ? node : node?.parentElement;
-    const owner = element?.closest(ownerSelector);
-    if (!owner || !root.contains(owner) || !node)
-        return null;
-    const range = root.ownerDocument.createRange();
-    range.selectNodeContents(owner);
-    try {
-        range.setEnd(node, offset);
-    }
-    catch {
-        return null;
-    }
-    return { ownerId: ownerId(owner), offset: contentWidth(range.cloneContents()) };
-};
-const captureSelection = (root) => {
-    const native = root.ownerDocument.defaultView?.getSelection();
-    if (!native?.anchorNode || !native.focusNode)
-        return null;
-    const anchor = pointInOwner(root, native.anchorNode, native.anchorOffset);
-    const head = pointInOwner(root, native.focusNode, native.focusOffset);
-    return anchor && head ? { anchor, head } : null;
-};
-const domPointAt = (owner, requested) => {
-    let remaining = Math.max(0, requested);
-    const visit = (parent) => {
-        for (let index = 0; index < parent.childNodes.length; index += 1) {
-            const child = parent.childNodes[index];
-            if (child.nodeType === child.TEXT_NODE) {
-                const length = child.nodeValue?.length || 0;
-                if (remaining <= length)
-                    return { node: child, offset: remaining };
-                remaining -= length;
-            }
-            else if (child instanceof HTMLElement && child.matches("br,[data-smart-atomic='true']")) {
-                if (remaining === 0)
-                    return { node: parent, offset: index };
-                if (remaining === 1)
-                    return { node: parent, offset: index + 1 };
-                remaining -= 1;
-            }
-            else if (!(child instanceof HTMLElement && child.closest("[data-smart-ui]"))) {
-                const found = visit(child);
-                if (found)
-                    return found;
-            }
-        }
-        return null;
-    };
-    return visit(owner) || { node: owner, offset: owner.childNodes.length };
-};
-const restoreSelection = (root, snapshot) => {
-    const byId = (id) => Array.from(root.querySelectorAll("[data-smart-id]"))
-        .find((node) => node.matches(ownerSelector) && node.dataset.smartId === id) || null;
-    const anchorOwner = byId(snapshot.anchor.ownerId);
-    const headOwner = byId(snapshot.head.ownerId);
-    const native = root.ownerDocument.defaultView?.getSelection();
-    if (!anchorOwner || !headOwner || !native)
-        return;
-    const anchor = domPointAt(anchorOwner, snapshot.anchor.offset);
-    const head = domPointAt(headOwner, snapshot.head.offset);
-    native.setBaseAndExtent(anchor.node, anchor.offset, head.node, head.offset);
-};
-const selectedOwners = (root, snapshot) => {
-    const owners = Array.from(root.querySelectorAll(ownerSelector));
-    const indexes = [snapshot.anchor.ownerId, snapshot.head.ownerId].map((id) => owners.findIndex((owner) => ownerId(owner) === id));
-    if (indexes.some((index) => index < 0))
-        return [];
-    const [from, to] = [Math.min(...indexes), Math.max(...indexes)];
-    return owners.slice(from, to + 1);
-};
-const modelSelection = (document, snapshot) => {
-    const positions = createScopeIndex().positions(document, foundationSchema);
-    const point = (value) => {
-        const content = positions.contentRangeOf(value.ownerId);
-        return content ? { path: [...content.from.path], offset: value.offset } : null;
-    };
-    const anchor = point(snapshot.anchor);
-    const head = point(snapshot.head);
-    return anchor && head ? { type: "text", anchor, head } : null;
-};
-const parseOwners = (owners) => parseCanonicalListHtml(owners.map((owner) => owner.outerHTML).join(""));
-const renderOwners = (root, owners, document, preserveEditedLink = false) => {
-    const template = root.ownerDocument.createElement("template");
-    template.innerHTML = serializeCanonicalListHtml(document, { fragment: true });
-    owners.forEach((owner) => {
-        const id = ownerId(owner);
-        const replacement = Array.from(template.content.querySelectorAll("[data-smart-id]"))
-            .find((candidate) => candidate.dataset.smartId === id);
-        if (replacement) {
-            const existingLinks = owner.querySelectorAll("a");
-            const replacementLinks = replacement.querySelectorAll("a");
-            if (preserveEditedLink && existingLinks.length === 1 && replacementLinks.length === 1
-                && existingLinks[0].textContent === replacementLinks[0].textContent
-                && owner.textContent === replacement.textContent) {
-                const next = replacementLinks[0];
-                existingLinks[0].setAttribute("href", next.getAttribute("href") || "");
-                if (next.target) {
-                    existingLinks[0].target = next.target;
-                    existingLinks[0].rel = "noopener noreferrer";
-                }
-                else {
-                    existingLinks[0].removeAttribute("target");
-                    existingLinks[0].removeAttribute("rel");
-                }
-                return;
-            }
-            owner.innerHTML = replacement.innerHTML;
-            owner.querySelectorAll("span[style]").forEach((span) => {
-                const color = span.style.color;
-                const background = span.style.backgroundColor;
-                const size = span.style.fontSize;
-                const family = span.style.fontFamily;
-                span.removeAttribute("style");
-                if (color)
-                    span.style.color = color;
-                if (background)
-                    span.style.backgroundColor = background;
-                if (size)
-                    span.style.fontSize = size;
-                if (family)
-                    span.style.fontFamily = family;
-            });
-        }
-    });
-};
-const declarationFor = (id) => {
-    const declaration = inlineToolDeclarations.find((tool) => tool.id === id);
-    if (!declaration)
-        throw new Error(`Unknown inline tool "${id}".`);
-    return declaration;
-};
-export const executeCanonicalInlineTool = (root, id, intent = "toggle", attrs) => {
-    const ownerElements = Array.from(root.querySelectorAll(ownerSelector));
-    const ownersWithPersistedIds = new Set(ownerElements.filter((owner) => owner.hasAttribute("data-smart-id")));
-    const cleanupTemporaryIds = () => ownerElements.forEach((owner) => {
-        if (!ownersWithPersistedIds.has(owner))
-            owner.removeAttribute("data-smart-id");
-    });
-    const snapshot = captureSelection(root);
-    if (!snapshot)
-        return { changed: false, operations: 0, coverage: "none" };
-    const owners = selectedOwners(root, snapshot);
-    if (!owners.length)
-        return { changed: false, operations: 0, coverage: "none" };
-    const document = parseOwners(owners);
-    const selection = modelSelection(document, snapshot);
-    if (!selection)
-        return { changed: false, operations: 0, coverage: "none" };
-    const declaration = declarationFor(id);
-    const index = createScopeIndex();
-    const scope = index.resolve(document, selection, { want: "inline-range" }, foundationSchema);
-    const description = index.resolve(document, selection, { want: "describe" }, foundationSchema);
-    const coverage = description.marks.some((entry) => entry.mark.type === declaration.markType && entry.coverage === "all")
-        ? "all" : description.marks.some((entry) => entry.mark.type === declaration.markType) ? "partial" : "none";
-    if (scope.collapsed && !(declaration.markType === "link" && (intent === "remove" || intent === "editLink"))) {
-        const editor = createFoundationEditor({ document, selection, storedMarks: storedMarks.get(root) });
-        executeMarkTool(editor, declaration, intent, attrs);
-        storedMarks.set(root, [...(editor.storedMarks || [])]);
-        cleanupTemporaryIds();
-        return { changed: false, operations: 0, coverage };
-    }
-    const ctx = { schema: foundationSchema, positions: index.positions(document, foundationSchema) };
-    const operations = intent === "clearAll" ? clearAllMarksCommand(document, scope, {}, ctx)
-        : intent === "remove" && declaration.markType === "link" ? removeLinkCommand(document, scope, { markType: "link" }, ctx)
-            : intent === "editLink" && declaration.markType === "link" ? editLinkCommand(document, scope, attrs, ctx)
-                : intent === "remove" ? removeMarkCommand(document, scope, { markType: declaration.markType }, ctx)
-                    : intent === "toggle" ? toggleMarkCommand(document, scope, { markType: declaration.markType, attrs, coverage }, ctx)
-                        : applyMarkCommand(document, scope, { markType: declaration.markType, attrs }, ctx);
-    if (!operations.length)
-        return { changed: false, operations: 0, coverage };
-    const output = applyOperations(document, operations);
-    renderOwners(root, owners, output, intent === "editLink");
-    restoreSelection(root, snapshot);
-    cleanupTemporaryIds();
-    storedMarks.delete(root);
-    return { changed: true, operations: operations.length, coverage };
-};
-/** Consumes adapter stored marks for ordinary text input. Composition remains
- * owned by the canonical surface; atom-aware composition is explicitly Phase 7. */
-export const installCanonicalInlineStoredMarkInput = (root) => {
-    const beforeInput = (event) => {
-        if (!storedMarks.has(root) || event.inputType !== "insertText" || !event.data)
-            return;
-        const marks = storedMarks.get(root) || [];
-        const ownerElements = Array.from(root.querySelectorAll(ownerSelector));
-        const ownersWithPersistedIds = new Set(ownerElements.filter((owner) => owner.hasAttribute("data-smart-id")));
-        const snapshot = captureSelection(root);
-        if (!snapshot || snapshot.anchor.ownerId !== snapshot.head.ownerId || snapshot.anchor.offset !== snapshot.head.offset)
-            return;
-        event.preventDefault();
-        const owners = selectedOwners(root, snapshot);
-        const document = parseOwners(owners);
-        const selection = modelSelection(document, snapshot);
-        if (!selection)
-            return;
-        const editor = createFoundationEditor({ document, selection, storedMarks: marks });
-        if (marks.length)
-            editor.typeText(event.data, { timestamp: Date.now() });
-        else
-            editor.transact((builder) => {
-                builder.operations.push({ type: "insertText", pos: selection.head, text: event.data });
-                const next = { path: [...selection.head.path], offset: selection.head.offset + event.data.length };
-                builder.setSelection({ type: "text", anchor: next, head: next });
-                builder.setStoredMarks([]);
-            }, { source: "input", timestamp: Date.now(), addToHistory: true });
-        renderOwners(root, owners, editor.document);
-        const next = { anchor: { ...snapshot.anchor, offset: snapshot.anchor.offset + event.data.length }, head: { ...snapshot.head, offset: snapshot.head.offset + event.data.length } };
-        restoreSelection(root, next);
-        ownerElements.forEach((owner) => { if (!ownersWithPersistedIds.has(owner))
-            owner.removeAttribute("data-smart-id"); });
-        storedMarks.set(root, [...(editor.storedMarks || [])]);
-    };
-    const selectionChange = () => {
-        const ownerElements = Array.from(root.querySelectorAll(ownerSelector));
-        const ownersWithPersistedIds = new Set(ownerElements.filter((owner) => owner.hasAttribute("data-smart-id")));
-        const snapshot = captureSelection(root);
-        if (!snapshot || snapshot.anchor.ownerId !== snapshot.head.ownerId || snapshot.anchor.offset !== snapshot.head.offset)
-            storedMarks.delete(root);
-        ownerElements.forEach((owner) => { if (!ownersWithPersistedIds.has(owner))
-            owner.removeAttribute("data-smart-id"); });
-    };
-    root.addEventListener("beforeinput", beforeInput);
-    root.ownerDocument.addEventListener("selectionchange", selectionChange);
-    return () => {
-        root.removeEventListener("beforeinput", beforeInput);
-        root.ownerDocument.removeEventListener("selectionchange", selectionChange);
-        storedMarks.delete(root);
-    };
-};
-export const canonicalInlineStoredMarks = (root) => storedMarks.get(root) || [];
-export const hasCanonicalInlineStoredMarkOverride = (root) => storedMarks.has(root);
-export const describeCanonicalInlineCoverage = (root) => {
-    if (storedMarks.has(root))
-        return Object.fromEntries((storedMarks.get(root) || []).map((mark) => [mark.type, "all"]));
-    const ownerElements = Array.from(root.querySelectorAll(ownerSelector));
-    const ownersWithPersistedIds = new Set(ownerElements.filter((owner) => owner.hasAttribute("data-smart-id")));
-    const snapshot = captureSelection(root);
-    if (!snapshot)
-        return {};
-    const owners = selectedOwners(root, snapshot);
-    const document = parseOwners(owners);
-    const selection = modelSelection(document, snapshot);
-    const description = selection
-        ? createScopeIndex().resolve(document, selection, { want: "describe" }, foundationSchema)
-        : null;
-    ownerElements.forEach((owner) => { if (!ownersWithPersistedIds.has(owner))
-        owner.removeAttribute("data-smart-id"); });
-    return Object.fromEntries((description?.marks || []).map((entry) => [entry.mark.type, entry.coverage]));
-};

package/dist/adapters/canonicalListCommandBridge.d.ts

@@ -1,26 +0,0 @@
-import { type SmartSelection } from "smartrte-core";
-export declare const executeCanonicalListDepth: (root: HTMLElement, items: readonly HTMLElement[], direction: "indent" | "outdent") => boolean;
-export declare const executeCanonicalListMove: (root: HTMLElement, items: readonly HTMLElement[], direction: "up" | "down") => boolean;
-export declare const executeCanonicalListStyle: (args: {
-    root: HTMLElement;
-    items: readonly HTMLElement[];
-    style?: string;
-    preset?: string;
-    checkable?: boolean;
-}) => boolean;
-export declare const executeCanonicalListCheck: (root: HTMLElement, item: HTMLElement, checked: boolean) => boolean;
-export declare const executeCanonicalListToggle: (args: {
-    root: HTMLElement;
-    items: readonly HTMLElement[];
-    blocks: readonly HTMLElement[];
-    listTag: "ul" | "ol";
-    range?: Range;
-    style?: string;
-    preset?: string;
-    checkable?: boolean;
-}) => boolean;
-export interface CanonicalListBridgeResult {
-    readonly changed: boolean;
-    readonly selection: SmartSelection | null;
-}
-export declare const executeCanonicalListStructuralInput: (root: HTMLElement, input: "enter" | "backspace" | "delete") => boolean;