@eocrm/design-system 0.0.0-stage → 0.6.17

package/src/components/RichText/engine/toMarkdown.ts

@@ -0,0 +1,97 @@
+// toMarkdown.ts — serialize a RichDoc to Markdown (CommonMark + GFM strikethrough,
+// restricted to the model). The inverse of fromMarkdown. Lossy: underline has no
+// Markdown syntax and is dropped — use toHtml for full fidelity.
+import type { RichDoc, Block, Inline, MarkType } from './model';
+import { runsText } from './inlines';
+import { safeHref } from './safeHref';
+import { isListItem, effectiveDepths } from './listDepths';
+import { attachmentIsImage } from './attachment';
+
+/** Backslash-escape inline specials so literal chars don't become formatting. */
+function escapeMd(s: string): string {
+  return s.replace(/[\\*_`[\]]/g, (c) => `\\${c}`);
+}
+
+/** Escape a leading block marker at the very start of the content. */
+function escapeLineStart(s: string): string {
+  return s.replace(/^(\s*)([#>+-]|\d+\.)/, '$1\\$2');
+}
+
+// Inline marks innermost → outermost (link applied last, outermost).
+const MARKERS: { type: MarkType; open: string; close: string }[] = [
+  { type: 'code', open: '`', close: '`' },
+  { type: 'strike', open: '~~', close: '~~' },
+  { type: 'italic', open: '*', close: '*' },
+  { type: 'bold', open: '**', close: '**' },
+];
+
+function inlineRun(run: Inline): string {
+  const isCode = run.marks.some((m) => m.type === 'code');
+  // Code content is verbatim; other text is MD-escaped. textColor/bgColor marks
+  // have no Markdown representation and are dropped (like underline) — the run's
+  // text passes through unchanged with no color markup.
+  let text = isCode ? run.text : escapeMd(run.text);
+  for (const m of MARKERS) {
+    if (run.marks.some((mk) => mk.type === m.type)) text = `${m.open}${text}${m.close}`;
+  }
+  const linkMark = run.marks.find((m) => m.type === 'link');
+  if (linkMark && linkMark.type === 'link') text = `[${text}](${safeHref(linkMark.href) ?? ''})`;
+  return text;
+}
+
+function blockMd(block: Block, depth: number): string {
+  if (block.type === 'code_block') return '```\n' + runsText(block.inlines) + '\n```';
+  if (block.type === 'attachment') {
+    // Only finalized attachments serialize; in-flight/failed uploads emit nothing.
+    if (block.status && block.status !== 'ready') return '';
+    // An unsafe src drops the whole block (consistent with toHtml) rather than
+    // emitting an empty-URL link.
+    const url = safeHref(block.src ?? '');
+    if (url === undefined) return '';
+    return attachmentIsImage(block)
+      ? `![${block.alt ?? block.name ?? ''}](${url})`
+      : `[${block.name ?? url}](${url})`;
+  }
+  const inline = escapeLineStart(block.inlines.map(inlineRun).join(''));
+  switch (block.type) {
+    case 'heading':
+      return `${'#'.repeat(block.level ?? 1)} ${inline}`;
+    case 'blockquote':
+      return `> ${inline}`;
+    case 'bullet_item':
+      return `${'  '.repeat(depth)}- ${inline}`;
+    case 'ordered_item':
+      return `${'  '.repeat(depth)}1. ${inline}`;
+    case 'paragraph':
+    default:
+      return inline;
+  }
+}
+
+/**
+ * Serialize a `RichDoc` to Markdown (CommonMark + GFM strikethrough), the inverse
+ * of `fromMarkdown`. Lossy: **underline and text/background color are dropped** (no
+ * Markdown syntax — use `toHtml` for full fidelity) and **mentions degrade to plain
+ * `@label` text** (the id is not representable in Markdown — `toHtml`/`fromHtml`
+ * preserve mentions); images/tables aren't modeled; MD-special escaping
+ * is best-effort.
+ *
+ * @example
+ * const md = toMarkdown(doc); // '# Title\n\n- one\n- two'
+ */
+export function toMarkdown(doc: RichDoc): string {
+  const eff = effectiveDepths(doc.blocks);
+  let out = '';
+  for (let i = 0; i < doc.blocks.length; i += 1) {
+    const b = doc.blocks[i];
+    if (i > 0) {
+      // Consecutive SAME-TYPE list items stay in one list (single newline). A
+      // bullet→ordered transition needs a blank line, or the Markdown parser would
+      // read both as one list and coerce the second to the first's type.
+      const prev = doc.blocks[i - 1];
+      out += isListItem(prev) && isListItem(b) && prev.type === b.type ? '\n' : '\n\n';
+    }
+    out += blockMd(b, isListItem(b) ? eff[i] : 0);
+  }
+  return out;
+}

package/src/components/RichText/engine/transforms.ts

@@ -0,0 +1,434 @@
+// transforms.ts — Layer D. Document transforms. Pure + immutable; each returns
+// { doc, selection } (the new doc + where the caret/selection should land).
+import type { RichDoc, Block, Point, Range, Mark, MarkType } from './model';
+import { createBlock, nextId } from './model';
+import { normalizeInlines, sliceInlines, mapMarksOverRange, runsLength } from './inlines';
+import { withMark, withoutMark, hasMark } from './marks';
+import {
+  blockLength,
+  findBlockIndex,
+  orderedRange,
+  isCollapsed,
+  collapsedRange,
+  marksForTypedText,
+} from './position';
+import { isVoidBlock } from './attachment';
+
+function collapsed(point: Point): Range {
+  return collapsedRange(point.blockId, point.offset);
+}
+
+function replaceBlock(doc: RichDoc, index: number, block: Block): RichDoc {
+  const blocks = doc.blocks.slice();
+  blocks[index] = block;
+  return { blocks };
+}
+
+/** Bounds of the mention run strictly containing `offset`, or null. */
+function mentionRunBoundsAt(block: Block, offset: number): { start: number; end: number } | null {
+  let pos = 0;
+  for (const run of block.inlines ?? []) {
+    const s = pos;
+    const e = pos + run.text.length;
+    pos = e;
+    if (offset > s && offset < e && run.marks.some((m) => m.type === 'mention')) {
+      return { start: s, end: e };
+    }
+  }
+  return null;
+}
+
+/** Snap a range START leftward out of any mention it bisects. */
+function snapStartOffset(block: Block, offset: number): number {
+  const b = mentionRunBoundsAt(block, offset);
+  return b ? b.start : offset;
+}
+
+/** Snap a range END rightward out of any mention it bisects. */
+function snapEndOffset(block: Block, offset: number): number {
+  const b = mentionRunBoundsAt(block, offset);
+  return b ? b.end : offset;
+}
+
+/**
+ * Pure/immutable. Insert `text` at `point`, inheriting the marks of the character
+ * immediately before the cursor (see {@link marksForTypedText} for the `mention`
+ * and `link` boundary exceptions). Returns `{ doc, selection }` with the caret
+ * placed after the inserted text. On a void block the text opens a new paragraph
+ * after the void. No-op (returns input unchanged) when `text` is empty or
+ * `point.blockId` does not exist in `doc`.
+ */
+export function insertText(
+  doc: RichDoc,
+  point: Point,
+  text: string,
+): { doc: RichDoc; selection: Range } {
+  if (text === '') return { doc, selection: collapsed(point) };
+  const idx = findBlockIndex(doc, point.blockId);
+  if (idx === -1) return { doc, selection: collapsed(point) };
+  const block = doc.blocks[idx];
+  // A void block (e.g. an attachment) holds no editable text — never splice the
+  // typed text into it. The caret sits beside it (e.g. after a doc-final image),
+  // so the text opens a new paragraph AFTER the void, like insertFragment does.
+  // ponytail: a caret BEFORE a void maps to the same {void, 0} point, so it also
+  // lands after; distinguishing would need a second void offset in the model.
+  if (isVoidBlock(block)) {
+    const after = createBlock('paragraph', text);
+    const blocks = [...doc.blocks.slice(0, idx + 1), after, ...doc.blocks.slice(idx + 1)];
+    return { doc: { blocks }, selection: collapsed({ blockId: after.id, offset: text.length }) };
+  }
+  const inlines = normalizeInlines([
+    ...sliceInlines(block.inlines, 0, point.offset),
+    { text, marks: marksForTypedText(doc, point) },
+    ...sliceInlines(block.inlines, point.offset, blockLength(block)),
+  ]);
+  return {
+    doc: replaceBlock(doc, idx, { ...block, inlines }),
+    selection: collapsed({ blockId: block.id, offset: point.offset + text.length }),
+  };
+}
+
+/**
+ * Pure/immutable. Delete the content covered by `range`. If `range` is collapsed
+ * (anchor === focus) returns `{ doc, selection }` unchanged — no-op. Cross-block
+ * ranges merge the surviving text of the start and end blocks. Returns `{ doc,
+ * selection }` with the caret at the deletion point.
+ */
+export function deleteRange(doc: RichDoc, range: Range): { doc: RichDoc; selection: Range } {
+  const ord = orderedRange(doc, range);
+  let start = ord.start;
+  let end = ord.end;
+  // Collapsed input → no-op (never snap a collapsed caret into a deletion).
+  if (start.blockId === end.blockId && start.offset === end.offset) {
+    return { doc, selection: collapsed(start) };
+  }
+  const si = findBlockIndex(doc, start.blockId);
+  const ei = findBlockIndex(doc, end.blockId);
+  if (si === -1 || ei === -1) return { doc, selection: collapsed(start) };
+  // Snap endpoints out of any mention run they bisect, so a partial selection (or
+  // a one-char backspace/forward-delete at a chip edge) removes the whole chip.
+  start = { ...start, offset: snapStartOffset(doc.blocks[si], start.offset) };
+  end = { ...end, offset: snapEndOffset(doc.blocks[ei], end.offset) };
+  const startBlock = doc.blocks[si];
+  const endBlock = doc.blocks[ei];
+  const startVoid = isVoidBlock(startBlock);
+  const endVoid = isVoidBlock(endBlock);
+  // A void block contributes no text to the merge. Crucially, the survivor must be
+  // a TEXT block — never `{...void, inlines: text}` (a model-illegal "attachment
+  // with text" that also drops the text from render/serialize). When the start is
+  // void, base the survivor on the end block (if it's text) else a fresh paragraph,
+  // but keep the start block's id so the caret target stays valid.
+  const inlines = normalizeInlines([
+    ...(startVoid ? [] : sliceInlines(startBlock.inlines, 0, start.offset)),
+    ...(endVoid ? [] : sliceInlines(endBlock.inlines, end.offset, blockLength(endBlock))),
+  ]);
+  let survivor: Block;
+  if (!startVoid) {
+    survivor = { ...startBlock, inlines };
+  } else if (!endVoid) {
+    survivor = { ...endBlock, id: startBlock.id, inlines };
+  } else {
+    survivor = { ...createBlock('paragraph', '', { id: startBlock.id }), inlines };
+  }
+  const blocks = doc.blocks.slice();
+  blocks.splice(si, ei - si + 1, survivor);
+  return {
+    doc: { blocks },
+    selection: collapsed({ blockId: startBlock.id, offset: startVoid ? 0 : start.offset }),
+  };
+}
+
+/**
+ * Pure/immutable. Split the block at `point` into two blocks of the same type,
+ * placing the caret at offset 0 of the new (right) block. On a void block it
+ * inserts an empty paragraph after the void instead. Returns `{ doc, selection }`.
+ * No-op (returns input) when `point.blockId` is not found.
+ */
+export function splitBlock(doc: RichDoc, point: Point): { doc: RichDoc; selection: Range } {
+  const idx = findBlockIndex(doc, point.blockId);
+  if (idx === -1) return { doc, selection: collapsed(point) };
+  const block = doc.blocks[idx];
+  if (isVoidBlock(block)) {
+    // Can't split a void — Enter beside it opens an empty paragraph after it.
+    const after = createBlock('paragraph');
+    const blocks = [...doc.blocks.slice(0, idx + 1), after, ...doc.blocks.slice(idx + 1)];
+    return { doc: { blocks }, selection: collapsed({ blockId: after.id, offset: 0 }) };
+  }
+  const left: Block = {
+    ...block,
+    inlines: normalizeInlines(sliceInlines(block.inlines, 0, point.offset)),
+  };
+  const rightInlines = normalizeInlines(
+    sliceInlines(block.inlines, point.offset, blockLength(block)),
+  );
+  const right: Block = {
+    ...createBlock(block.type, '', { level: block.level, depth: block.depth }),
+    inlines: rightInlines,
+  };
+  const blocks = doc.blocks.slice();
+  blocks.splice(idx, 1, left, right);
+  return { doc: { blocks }, selection: collapsed({ blockId: right.id, offset: 0 }) };
+}
+
+/**
+ * Pure/immutable. Merge the block identified by `blockId` into the preceding
+ * block, appending its inlines. Returns `{ doc, selection }` with the caret at the
+ * join point. No-op (returns input) when `blockId` is the first block in the doc.
+ */
+export function mergeBlockBackward(
+  doc: RichDoc,
+  blockId: string,
+): { doc: RichDoc; selection: Range } {
+  const idx = findBlockIndex(doc, blockId);
+  if (idx <= 0) return { doc, selection: collapsed({ blockId, offset: 0 }) };
+  const prev = doc.blocks[idx - 1];
+  const cur = doc.blocks[idx];
+  if (isVoidBlock(prev)) {
+    const blocks = doc.blocks.slice();
+    blocks.splice(idx - 1, 1); // drop the preceding void; `cur` shifts up
+    return { doc: { blocks }, selection: collapsed({ blockId: cur.id, offset: 0 }) };
+  }
+  if (isVoidBlock(cur)) {
+    const blocks = doc.blocks.slice();
+    blocks.splice(idx, 1); // drop the void; caret to end of prev
+    return {
+      doc: { blocks },
+      selection: collapsed({ blockId: prev.id, offset: blockLength(prev) }),
+    };
+  }
+  const joinOffset = blockLength(prev);
+  const inlines = normalizeInlines([...prev.inlines, ...cur.inlines]);
+  const blocks = doc.blocks.slice();
+  blocks.splice(idx - 1, 2, { ...prev, inlines });
+  return { doc: { blocks }, selection: collapsed({ blockId: prev.id, offset: joinOffset }) };
+}
+
+function transformMarksOverRange(
+  doc: RichDoc,
+  range: Range,
+  fn: (marks: Mark[]) => Mark[],
+): { doc: RichDoc; selection: Range } {
+  const { start, end } = orderedRange(doc, range);
+  const si = findBlockIndex(doc, start.blockId);
+  const ei = findBlockIndex(doc, end.blockId);
+  if (si === -1 || ei === -1) return { doc, selection: range };
+  const blocks = doc.blocks.slice();
+  for (let i = si; i <= ei; i += 1) {
+    const block = blocks[i];
+    const from = i === si ? start.offset : 0;
+    const to = i === ei ? end.offset : blockLength(block);
+    if (to <= from) continue;
+    blocks[i] = { ...block, inlines: mapMarksOverRange(block.inlines, from, to, fn) };
+  }
+  return { doc: { blocks }, selection: range };
+}
+
+/**
+ * Pure/immutable. Apply `mark` to every character in `range`, splitting inline
+ * runs at the boundaries as needed. Returns `{ doc, selection }` with the
+ * original range preserved.
+ */
+export function applyMark(
+  doc: RichDoc,
+  range: Range,
+  mark: Mark,
+): { doc: RichDoc; selection: Range } {
+  return transformMarksOverRange(doc, range, (m) => withMark(m, mark));
+}
+
+/**
+ * Pure/immutable. Remove the mark of `type` from every character in `range`.
+ * Returns `{ doc, selection }` with the original range preserved.
+ */
+export function removeMark(
+  doc: RichDoc,
+  range: Range,
+  type: MarkType,
+): { doc: RichDoc; selection: Range } {
+  return transformMarksOverRange(doc, range, (m) => withoutMark(m, type));
+}
+
+/** True iff every character in the (non-empty) range carries `type`. */
+function rangeHasMarkEverywhere(doc: RichDoc, range: Range, type: MarkType): boolean {
+  const { start, end } = orderedRange(doc, range);
+  if (start.blockId === end.blockId && start.offset === end.offset) return false;
+  const si = findBlockIndex(doc, start.blockId);
+  const ei = findBlockIndex(doc, end.blockId);
+  if (si === -1 || ei === -1) return false;
+  for (let i = si; i <= ei; i += 1) {
+    const block = doc.blocks[i];
+    const from = i === si ? start.offset : 0;
+    const to = i === ei ? end.offset : blockLength(block);
+    if (to <= from) continue;
+    let pos = 0;
+    for (const run of block.inlines) {
+      const rs = pos;
+      const re = pos + run.text.length;
+      pos = re;
+      const f = Math.max(from, rs);
+      const t = Math.min(to, re);
+      if (t > f && !hasMark(run.marks, type)) return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Pure/immutable. If every character in `range` already carries `mark.type`,
+ * removes it (via `removeMark`); otherwise applies it (via `applyMark`). Returns
+ * `{ doc, selection }` with the original range preserved.
+ */
+export function toggleMark(
+  doc: RichDoc,
+  range: Range,
+  mark: Mark,
+): { doc: RichDoc; selection: Range } {
+  return rangeHasMarkEverywhere(doc, range, mark.type)
+    ? removeMark(doc, range, mark.type)
+    : applyMark(doc, range, mark);
+}
+
+/**
+ * Pure/immutable. Set (or clear) the single color mark of `type`
+ * (`'textColor'` | `'bgColor'`) over `range`. The run carries at most one color
+ * mark of each type: a non-null `key` REPLACES any existing one (clear-then-apply);
+ * a `null` key CLEARS it. `key` is a palette key (e.g. `'red'`), resolved to a
+ * token at render/serialize time — see `colorMarks.ts`. Returns the new `RichDoc`.
+ *
+ * Note: returns a bare `RichDoc` (not `{ doc, selection }` like the lower-level
+ * `applyMark`/`removeMark`) because a color change never moves the caret — callers
+ * keep their existing selection.
+ */
+export function setColorMark(
+  doc: RichDoc,
+  range: Range,
+  type: 'textColor' | 'bgColor',
+  key: string | null,
+): RichDoc {
+  const cleared = removeMark(doc, range, type).doc;
+  return key ? applyMark(cleared, range, { type, color: key }).doc : cleared;
+}
+
+/**
+ * Pure/immutable. Patch the `type`, `level`, and/or `depth` of the block
+ * identified by `blockId`. Cleans up irrelevant fields (`level` for non-headings,
+ * `depth` for non-list blocks). Returns `{ doc, selection }` with the caret at
+ * offset 0 of the block. No-op (returns input) when `blockId` is not found, or
+ * when the target is a void block (an attachment can't become a heading/list —
+ * converting it would strip the figure rendering and silently lose the file).
+ */
+export function setBlockType(
+  doc: RichDoc,
+  blockId: string,
+  patch: Partial<Pick<Block, 'type' | 'level' | 'depth'>>,
+): { doc: RichDoc; selection: Range } {
+  const idx = findBlockIndex(doc, blockId);
+  if (idx === -1) return { doc, selection: collapsed({ blockId, offset: 0 }) };
+  if (isVoidBlock(doc.blocks[idx])) return { doc, selection: collapsed({ blockId, offset: 0 }) };
+  const next: Block = { ...doc.blocks[idx], ...patch };
+  if (next.type !== 'heading') delete next.level;
+  if (next.type !== 'bullet_item' && next.type !== 'ordered_item') delete next.depth;
+  return { doc: replaceBlock(doc, idx, next), selection: collapsed({ blockId, offset: 0 }) };
+}
+
+/**
+ * Pure/immutable. Insert a multi-block `fragment` at `range`, replacing any
+ * selection, with the conventional paste merge: the fragment's first block
+ * continues the current line and its last block rejoins the trailing text.
+ * Returns `{ doc, selection }` with the caret at the join. An empty fragment is
+ * a no-op (returns the input doc + a collapsed caret).
+ */
+export function insertFragment(
+  doc: RichDoc,
+  range: Range,
+  fragment: RichDoc,
+): { doc: RichDoc; selection: Range } {
+  const frag = fragment.blocks;
+  const fragEmpty = frag.length === 0 || (frag.length === 1 && blockLength(frag[0]) === 0);
+
+  const base = isCollapsed(range) ? { doc, selection: range } : deleteRange(doc, range);
+  const caret = base.selection.anchor;
+  if (fragEmpty) return { doc: base.doc, selection: collapsed(caret) };
+
+  const idx = findBlockIndex(base.doc, caret.blockId);
+  if (idx === -1) return { doc: base.doc, selection: collapsed(caret) };
+  const B = base.doc.blocks[idx];
+  // Caret resting on a void block (e.g. paste while the caret sits on an
+  // attachment): never merge the fragment's text INTO the void — splice the
+  // fragment's blocks (fresh ids) immediately after it, caret at the last block.
+  if (isVoidBlock(B)) {
+    const inserted = frag.map((b) => ({ ...b, id: nextId() }));
+    const blocks = base.doc.blocks.slice();
+    blocks.splice(idx + 1, 0, ...inserted);
+    const lastInserted = inserted[inserted.length - 1];
+    return {
+      doc: { blocks },
+      selection: collapsed({ blockId: lastInserted.id, offset: blockLength(lastInserted) }),
+    };
+  }
+  const left = sliceInlines(B.inlines, 0, caret.offset);
+  const right = sliceInlines(B.inlines, caret.offset, blockLength(B));
+
+  if (frag.length === 1) {
+    const merged = normalizeInlines([...left, ...frag[0].inlines, ...right]);
+    const offset = caret.offset + runsLength(frag[0].inlines);
+    return {
+      doc: replaceBlock(base.doc, idx, { ...B, inlines: merged }),
+      selection: collapsed({ blockId: B.id, offset }),
+    };
+  }
+
+  const first = frag[0];
+  const last = frag[frag.length - 1];
+  const middle = frag.slice(1, -1).map((b) => ({ ...b, id: nextId() }));
+  const bleft: Block = { ...B, inlines: normalizeInlines([...left, ...first.inlines]) };
+  const bright: Block = {
+    ...last,
+    id: nextId(),
+    inlines: normalizeInlines([...last.inlines, ...right]),
+  };
+  const blocks = base.doc.blocks.slice();
+  blocks.splice(idx, 1, bleft, ...middle, bright);
+  return {
+    doc: { blocks },
+    selection: collapsed({ blockId: bright.id, offset: runsLength(last.inlines) }),
+  };
+}
+
+/**
+ * Pure/immutable. Replace the block-relative span `[range.from, range.to)` with a
+ * mention chip run (`text: trigger + mention.label`, mark `{type:'mention', id,
+ * label}`) followed by a single trailing space. Returns `{ doc, selection }` with
+ * the caret after the trailing space. No-op (collapsed caret at `range.from`) when
+ * `blockId` is not found.
+ */
+export function insertMention(
+  doc: RichDoc,
+  blockId: string,
+  range: { from: number; to: number },
+  trigger: string,
+  mention: { id: string; label: string },
+): { doc: RichDoc; selection: Range } {
+  const idx = findBlockIndex(doc, blockId);
+  if (idx === -1) return { doc, selection: collapsed({ blockId, offset: range.from }) };
+  // Defense-in-depth: a void block holds no text to replace (no UI path forms a
+  // mention inside one, but keep the engine uniformly void-safe).
+  if (isVoidBlock(doc.blocks[idx]))
+    return { doc, selection: collapsed({ blockId, offset: range.from }) };
+  // Defensive clamp: tolerate an inverted range (from > to). No-op for valid input.
+  const from = Math.min(range.from, range.to);
+  const to = Math.max(range.from, range.to);
+  const block = doc.blocks[idx];
+  const chipText = `${trigger}${mention.label}`;
+  const inlines = normalizeInlines([
+    ...sliceInlines(block.inlines, 0, from),
+    { text: chipText, marks: [{ type: 'mention', id: mention.id, label: mention.label }] },
+    { text: ' ', marks: [] },
+    ...sliceInlines(block.inlines, to, blockLength(block)),
+  ]);
+  const offset = from + chipText.length + 1;
+  return {
+    doc: replaceBlock(doc, idx, { ...block, inlines }),
+    selection: collapsed({ blockId, offset }),
+  };
+}

package/src/components/RichText/imageMaxHeightStyle.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties } from 'react';
+
+/** Inline style carrying `imageMaxHeight` to the image rule; consumer style wins on conflict. */
+export function imageMaxHeightStyle(
+  imageMaxHeight: number | undefined,
+  style: CSSProperties | undefined,
+): CSSProperties | undefined {
+  if (imageMaxHeight === undefined) return style;
+  return { '--rich-text-image-max-height': `${imageMaxHeight}px`, ...style } as CSSProperties;
+}

package/src/components/RichText/index.ts

@@ -0,0 +1,31 @@
+export { RichText } from './RichText';
+export type { RichTextProps } from './RichText';
+// Model types are exported with a `Rich` prefix so the package's flat namespace
+// doesn't claim generic names — `Block`/`Mark`/`Point`/`Inline` are likely future
+// collisions and `Range` shadows the DOM global. The engine keeps the short names
+// internally; only the public surface is prefixed.
+export type {
+  RichDoc,
+  Block as RichBlock,
+  BlockType as RichBlockType,
+  Inline as RichInline,
+  Mark as RichMark,
+  MarkType as RichMarkType,
+  Point as RichPoint,
+  Range as RichRange,
+} from './engine/model';
+export { emptyDoc, createBlock, docFromText } from './engine/model';
+export {
+  insertText,
+  deleteRange,
+  splitBlock,
+  mergeBlockBackward,
+  applyMark,
+  removeMark,
+  toggleMark,
+  setBlockType,
+} from './engine/transforms';
+export { fromHtml } from './engine/fromHtml';
+export { fromMarkdown } from './engine/fromMarkdown';
+export { toHtml } from './engine/toHtml';
+export { toMarkdown } from './engine/toMarkdown';