@sofereditor/core 0.2.0 → 0.3.1

package/dist/index.js

@@ -89,6 +89,19 @@ function withDefaults(partial) {
 
 // src/document.ts
 import * as Y from "yjs";
+function newBlockId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `b-${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+function getBlockId(block) {
+  const id = block.get("id");
+  return typeof id === "string" ? id : void 0;
+}
 var EditorDocument = class _EditorDocument {
   ydoc;
   blocks;
@@ -350,6 +363,7 @@ function createBlock(type, initialText = "", attrs) {
     return createTableBlock(rows, cols);
   }
   const block = new Y.Map();
+  block.set("id", newBlockId());
   block.set("type", type);
   const yText = new Y.Text();
   if (initialText.length > 0) yText.insert(0, initialText);
@@ -366,6 +380,7 @@ function createTableBlock(rows, cols) {
   const r = Math.max(1, Math.trunc(rows));
   const c = Math.max(1, Math.trunc(cols));
   const block = new Y.Map();
+  block.set("id", newBlockId());
   block.set("type", "table");
   const attrsMap = new Y.Map();
   attrsMap.set("rows", r);
@@ -400,6 +415,7 @@ function buildEmptyBlockFromSerialized(block) {
     const rows = typeof block.attrs.rows === "number" ? Math.max(1, Math.trunc(block.attrs.rows)) : 1;
     const cols = typeof block.attrs.cols === "number" ? Math.max(1, Math.trunc(block.attrs.cols)) : 1;
     const yBlock = new Y.Map();
+    yBlock.set("id", typeof block.id === "string" ? block.id : newBlockId());
     yBlock.set("type", "table");
     const attrsMap = new Y.Map();
     attrsMap.set("rows", rows);
@@ -422,7 +438,9 @@ function buildEmptyBlockFromSerialized(block) {
     yBlock.set("cells", cellsArr);
     return yBlock;
   }
-  return createBlock(block.type, "", block.attrs);
+  const yb = createBlock(block.type, "", block.attrs);
+  if (typeof block.id === "string") yb.set("id", block.id);
+  return yb;
 }
 function applyDeltaIntoBlock(yBlock, src) {
   if (!yBlock) return;
@@ -450,6 +468,95 @@ function spanOf(value) {
   return Math.max(1, Math.trunc(value));
 }
 
+// src/collab-cursor.ts
+import * as Y2 from "yjs";
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+  return btoa(s);
+}
+function fromBase64(b64) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(b64, "base64"));
+  const s = atob(b64);
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+function yTextAt(doc, pos) {
+  const block = doc.blocks.get(pos.blockIndex);
+  if (!block) return null;
+  if (typeof pos.cellIndex === "number") {
+    const cells = block.get("cells");
+    const cell = cells?.get(pos.cellIndex);
+    const t2 = cell?.get("text");
+    return t2 instanceof Y2.Text ? t2 : null;
+  }
+  const t = block.get("text");
+  return t instanceof Y2.Text ? t : null;
+}
+function locateYText(doc, target) {
+  const blocks = doc.blocks;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks.get(i);
+    if (block.get("text") === target) return { blockIndex: i };
+    const cells = block.get("cells");
+    if (cells) {
+      for (let c = 0; c < cells.length; c++) {
+        if (cells.get(c)?.get("text") === target) {
+          return { blockIndex: i, cellIndex: c };
+        }
+      }
+    }
+  }
+  return null;
+}
+function encodePoint(doc, pos) {
+  const yText = yTextAt(doc, pos);
+  if (!yText) return null;
+  const offset = Math.max(0, Math.min(pos.offset, yText.length));
+  const rel = Y2.createRelativePositionFromTypeIndex(yText, offset);
+  const block = doc.blocks.get(pos.blockIndex);
+  const point = { rel: toBase64(Y2.encodeRelativePosition(rel)) };
+  const blockId = block ? getBlockId(block) : void 0;
+  if (blockId) point.blockId = blockId;
+  if (typeof pos.cellIndex === "number") point.cellIndex = pos.cellIndex;
+  return point;
+}
+function decodePoint(doc, enc) {
+  try {
+    const rel = Y2.decodeRelativePosition(fromBase64(enc.rel));
+    const abs = Y2.createAbsolutePositionFromRelativePosition(rel, doc.ydoc);
+    if (abs && abs.type instanceof Y2.Text) {
+      const loc = locateYText(doc, abs.type);
+      if (loc) return { ...loc, offset: abs.index };
+    }
+  } catch {
+  }
+  if (enc.blockId) {
+    for (let i = 0; i < doc.blocks.length; i++) {
+      if (getBlockId(doc.blocks.get(i)) === enc.blockId) {
+        const p = { blockIndex: i, offset: 0 };
+        if (typeof enc.cellIndex === "number") p.cellIndex = enc.cellIndex;
+        return p;
+      }
+    }
+  }
+  return null;
+}
+function encodeSelection(doc, sel) {
+  const anchor = encodePoint(doc, sel.anchor);
+  const focus = encodePoint(doc, sel.focus);
+  if (!anchor || !focus) return null;
+  return { anchor, focus };
+}
+function decodeSelection(doc, enc) {
+  const anchor = decodePoint(doc, enc.anchor);
+  const focus = decodePoint(doc, enc.focus);
+  if (!anchor || !focus) return null;
+  return { anchor, focus };
+}
+
 // src/selection.ts
 function isCollapsed(sel) {
   return positionsEqual(sel.anchor, sel.focus);
@@ -478,6 +585,20 @@ function sameTextRun(a, b) {
 }
 
 // src/marks.ts
+var ALL_MARKS = {
+  bold: true,
+  italic: true,
+  underline: true,
+  strike: true,
+  color: true,
+  fontFamily: true,
+  fontSize: true,
+  link: true,
+  comment: true
+};
+var CLEAR_ALL_MARKS = Object.fromEntries(
+  Object.keys(ALL_MARKS).map((k) => [k, null])
+);
 function iterateRunsInRange(yText, start, end, visit) {
   if (start >= end) return;
   const delta = yText.toDelta();
@@ -602,7 +723,87 @@ function sameMarkValue(a, b) {
 }
 
 // src/commands.ts
-import * as Y2 from "yjs";
+import * as Y3 from "yjs";
+
+// src/clipboard.ts
+var SOFER_MIME = "application/x-sofer-slice";
+function deltaToText(delta) {
+  let s = "";
+  for (const op of delta) if (typeof op.insert === "string") s += op.insert;
+  return s;
+}
+function blockFromDelta(doc, blockIndex, cellIndex, delta) {
+  if (cellIndex != null) {
+    return { type: "paragraph", text: deltaToText(delta), delta, attrs: {} };
+  }
+  return {
+    type: doc.getBlockType(blockIndex) ?? "paragraph",
+    text: deltaToText(delta),
+    delta,
+    attrs: doc.getBlockAttrs(blockIndex)
+  };
+}
+function serializeSelection(doc, sel) {
+  if (isCollapsed(sel)) return null;
+  const { start, end } = orderedRange(sel);
+  if ((start.cellIndex ?? -1) !== (end.cellIndex ?? -1)) return null;
+  if (start.blockIndex === end.blockIndex) {
+    const yText = doc.textAt(start.blockIndex, start.cellIndex);
+    if (!yText) return null;
+    const delta = sliceDelta(yText.toDelta(), start.offset, end.offset);
+    return {
+      blocks: [blockFromDelta(doc, start.blockIndex, start.cellIndex, delta)],
+      openStart: start.offset > 0,
+      openEnd: end.offset < yText.length
+    };
+  }
+  if (start.cellIndex != null || end.cellIndex != null) return null;
+  for (let i = start.blockIndex; i <= end.blockIndex; i++) {
+    if (doc.getBlockType(i) === "table") return null;
+  }
+  const startText = doc.getBlockText(start.blockIndex);
+  const endText = doc.getBlockText(end.blockIndex);
+  if (!startText || !endText) return null;
+  const blocks = [];
+  blocks.push(
+    blockFromDelta(
+      doc,
+      start.blockIndex,
+      void 0,
+      sliceDelta(startText.toDelta(), start.offset, startText.length)
+    )
+  );
+  for (let i = start.blockIndex + 1; i < end.blockIndex; i++) {
+    const t = doc.getBlockText(i);
+    blocks.push(blockFromDelta(doc, i, void 0, t?.toDelta() ?? []));
+  }
+  blocks.push(
+    blockFromDelta(
+      doc,
+      end.blockIndex,
+      void 0,
+      sliceDelta(endText.toDelta(), 0, end.offset)
+    )
+  );
+  return {
+    blocks,
+    openStart: start.offset > 0,
+    openEnd: end.offset < endText.length
+  };
+}
+function sliceToText(slice) {
+  return slice.blocks.map((b) => deltaToText(b.delta)).join("\n");
+}
+function sliceToInlineDelta(slice) {
+  const out = [];
+  slice.blocks.forEach((b, i) => {
+    if (i > 0) out.push({ insert: "\n" });
+    out.push(...b.delta);
+  });
+  return out;
+}
+
+// src/commands.ts
 var COMMAND_ORIGIN = /* @__PURE__ */ Symbol("editor-command");
 function transact(doc, fn) {
   doc.ydoc.transact(fn, COMMAND_ORIGIN);
@@ -811,7 +1012,7 @@ function setBlockType(ctx, type, attrs) {
       const block = ctx.doc.getBlock(i);
       if (!block) continue;
       block.set("type", type);
-      const attrsMap = block.get("attrs") ?? new Y2.Map();
+      const attrsMap = block.get("attrs") ?? new Y3.Map();
       if (!block.get("attrs")) block.set("attrs", attrsMap);
       const next = { ...defaultAttrsFor(type), ...attrs ?? {} };
       const keep = new Set(Object.keys(next));
@@ -834,7 +1035,7 @@ function setBlockAttr(ctx, key, value) {
     for (const i of indices) {
       const block = ctx.doc.getBlock(i);
       if (!block) continue;
-      const attrsMap = block.get("attrs") ?? new Y2.Map();
+      const attrsMap = block.get("attrs") ?? new Y3.Map();
       if (!block.get("attrs")) block.set("attrs", attrsMap);
       if (value === null || value === void 0) {
         attrsMap.delete(key);
@@ -845,6 +1046,109 @@ function setBlockAttr(ctx, key, value) {
     ctx.setSelection(sel);
   });
 }
+function setCellAttr(ctx, key, value) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    const { blockIndex, cellIndex } = sel.focus;
+    if (cellIndex == null || !ctx.doc.isTable(blockIndex)) return;
+    const { cols } = ctx.doc.getTableSize(blockIndex);
+    if (cols <= 0) return;
+    const rect = tableRectSelection(ctx.doc, sel);
+    const targets = [];
+    if (rect) {
+      for (let r = rect.top; r <= rect.bottom; r++)
+        for (let c = rect.left; c <= rect.right; c++) targets.push(r * cols + c);
+    } else {
+      const real = ctx.doc.realCellIndex(blockIndex, cellIndex);
+      if (real != null) targets.push(real);
+    }
+    for (const flat of targets) {
+      if (ctx.doc.getCellAttrs(blockIndex, flat).covered) continue;
+      const m = ctx.doc.getCellAttrsMap(blockIndex, flat);
+      if (!m) continue;
+      if (value === null || value === void 0) m.delete(key);
+      else m.set(key, value);
+    }
+    ctx.setSelection(sel);
+  });
+}
+function deleteSelection(ctx) {
+  transact(ctx.doc, () => {
+    const s = deleteRange(ctx.doc, ctx.getSelection());
+    ctx.setSelection(s);
+  });
+}
+function insertSlice(ctx, slice) {
+  if (!slice.blocks || slice.blocks.length === 0) return;
+  transact(ctx.doc, () => {
+    let sel = ctx.getSelection();
+    if (!isCollapsed(sel)) sel = deleteRange(ctx.doc, sel);
+    const { blockIndex, cellIndex, offset } = sel.focus;
+    if (cellIndex != null) {
+      const cellText = ctx.doc.textAt(blockIndex, cellIndex);
+      if (!cellText) return;
+      const after = writeDeltaInto(cellText, offset, sliceToInlineDelta(slice));
+      ctx.setSelection(collapsedSelection({ blockIndex, cellIndex, offset: after }));
+      return;
+    }
+    const targetText = ctx.doc.getBlockText(blockIndex);
+    if (!targetText) return;
+    const full = targetText.toDelta();
+    const tailDelta = sliceDelta(full, offset, deltaLength(full));
+    targetText.delete(offset, targetText.length - offset);
+    const blocks = slice.blocks;
+    if (blocks.length === 1) {
+      const afterS0 = writeDeltaInto(targetText, offset, blocks[0].delta);
+      writeDeltaInto(targetText, afterS0, tailDelta);
+      ctx.setSelection(collapsedSelection({ blockIndex, offset: afterS0 }));
+      return;
+    }
+    const originalType = ctx.doc.getBlockType(blockIndex);
+    const originalAttrs = ctx.doc.getBlockAttrs(blockIndex);
+    let insertAt = blockIndex;
+    if (slice.openStart) {
+      writeDeltaInto(targetText, offset, blocks[0].delta);
+    } else if (offset === 0) {
+      const blk = ctx.doc.blocks.get(blockIndex);
+      blk.set("type", blocks[0].type);
+      const am = blk.get("attrs");
+      am.clear();
+      for (const [k, v] of Object.entries(blocks[0].attrs)) {
+        if (v !== void 0) am.set(k, v);
+      }
+      writeDeltaInto(targetText, 0, blocks[0].delta);
+    } else {
+      const b = createBlock(blocks[0].type, "", blocks[0].attrs);
+      ctx.doc.blocks.insert(++insertAt, [b]);
+      writeDeltaInto(b.get("text"), 0, blocks[0].delta);
+    }
+    for (let i = 1; i < blocks.length - 1; i++) {
+      const b = createBlock(blocks[i].type, "", blocks[i].attrs);
+      ctx.doc.blocks.insert(++insertAt, [b]);
+      writeDeltaInto(b.get("text"), 0, blocks[i].delta);
+    }
+    const last = blocks[blocks.length - 1];
+    if (slice.openEnd) {
+      const b = createBlock(last.type, "", last.attrs);
+      ctx.doc.blocks.insert(++insertAt, [b]);
+      const t = b.get("text");
+      const caretPos = writeDeltaInto(t, 0, last.delta);
+      writeDeltaInto(t, caretPos, tailDelta);
+      ctx.setSelection(collapsedSelection({ blockIndex: insertAt, offset: caretPos }));
+    } else {
+      const b = createBlock(last.type, "", last.attrs);
+      ctx.doc.blocks.insert(++insertAt, [b]);
+      const lastLen = writeDeltaInto(b.get("text"), 0, last.delta);
+      const lastIdx = insertAt;
+      if (tailDelta.length > 0) {
+        const tb = createBlock(originalType ?? "paragraph", "", originalAttrs);
+        ctx.doc.blocks.insert(++insertAt, [tb]);
+        writeDeltaInto(tb.get("text"), 0, tailDelta);
+      }
+      ctx.setSelection(collapsedSelection({ blockIndex: lastIdx, offset: lastLen }));
+    }
+  });
+}
 function selectedBlockIndices(sel, blockCount) {
   const { start, end } = orderedRange(sel);
   const out = [];
@@ -994,7 +1298,7 @@ function setBlockTypeAtIndex(doc, index, type, attrs) {
   const block = doc.getBlock(index);
   if (!block) return;
   block.set("type", type);
-  const attrsMap = block.get("attrs") ?? new Y2.Map();
+  const attrsMap = block.get("attrs") ?? new Y3.Map();
   if (!block.get("attrs")) block.set("attrs", attrsMap);
   const next = { ...defaultAttrsFor(type), ...attrs };
   const keep = new Set(Object.keys(next));
@@ -1018,6 +1322,9 @@ function insertTable(ctx, rows, cols) {
     const focusBlock = Math.max(0, Math.min(sel.focus.blockIndex, ctx.doc.blockCount() - 1));
     const insertAt = focusBlock + 1;
     ctx.doc.blocks.insert(insertAt, [createTableBlock(r, c)]);
+    if (insertAt === ctx.doc.blockCount() - 1) {
+      ctx.doc.blocks.insert(insertAt + 1, [createBlock("paragraph")]);
+    }
     ctx.setSelection(
       collapsedSelection({ blockIndex: insertAt, cellIndex: 0, offset: 0 })
     );
@@ -1626,11 +1933,10 @@ function writeDeltaInto(yText, pos, delta) {
   for (const op of delta) {
     if (typeof op.insert === "string") {
       if (op.insert.length === 0) continue;
-      if (op.attributes && Object.keys(op.attributes).length > 0) {
-        yText.insert(cursor, op.insert, op.attributes);
-      } else {
-        yText.insert(cursor, op.insert);
-      }
+      yText.insert(cursor, op.insert, {
+        ...CLEAR_ALL_MARKS,
+        ...op.attributes ?? {}
+      });
       cursor += op.insert.length;
     } else if (op.insert != null) {
       if (op.attributes && Object.keys(op.attributes).length > 0) {
@@ -1690,17 +1996,56 @@ function setImageAttrs(ctx, blockIndex, embedOffset, partial, cellIndex, newOffs
     yText.insert(insertAt, merged);
   });
 }
+var REANCHORABLE_LAYOUTS = /* @__PURE__ */ new Set(["front", "behind"]);
+function moveEmbedAnchor(ctx, from, to, newOffsetX, newOffsetY) {
+  transact(ctx.doc, () => {
+    const srcText = ctx.doc.textAt(from.blockIndex, from.cellIndex);
+    if (!srcText) return;
+    const delta = srcText.toDelta();
+    let cursor = 0;
+    let prev = null;
+    for (const op of delta) {
+      if (typeof op.insert === "string") {
+        cursor += op.insert.length;
+        continue;
+      }
+      if (cursor === from.offset && isImageEmbed(op.insert)) {
+        prev = op.insert;
+        break;
+      }
+      cursor += 1;
+    }
+    if (!prev) return;
+    const layout = prev.layout ?? "inline";
+    if (!REANCHORABLE_LAYOUTS.has(layout)) return;
+    const dstText = ctx.doc.textAt(to.blockIndex, to.cellIndex);
+    if (!dstText) return;
+    const merged = { ...prev, offsetX: newOffsetX, offsetY: newOffsetY };
+    const sameRun = srcText === dstText;
+    srcText.delete(from.offset, 1);
+    let landed = to.offset;
+    if (sameRun && to.offset > from.offset) {
+      landed = to.offset - 1;
+    }
+    landed = Math.max(0, Math.min(landed, dstText.length));
+    dstText.insert(landed, merged);
+    ctx.setSelection({
+      anchor: { blockIndex: to.blockIndex, cellIndex: to.cellIndex, offset: landed },
+      focus: { blockIndex: to.blockIndex, cellIndex: to.cellIndex, offset: landed + 1 }
+    });
+  });
+}
 function isCommandOrigin(origin) {
   return origin === COMMAND_ORIGIN;
 }
 var TRACKED_ORIGINS = /* @__PURE__ */ new Set([COMMAND_ORIGIN]);
 
 // src/history.ts
-import * as Y3 from "yjs";
+import * as Y4 from "yjs";
 var EditorHistory = class {
   undoManager;
   constructor(doc) {
-    this.undoManager = new Y3.UndoManager(doc.blocks, {
+    this.undoManager = new Y4.UndoManager(doc.blocks, {
       trackedOrigins: TRACKED_ORIGINS,
       captureTimeout: 400
     });
@@ -1717,6 +2062,7 @@ var EditorHistory = class {
 };
 export {
   BLOCK_SPECS,
+  CLEAR_ALL_MARKS,
   COMMAND_ORIGIN,
   DEFAULT_PAGE_SETTINGS,
   EditorDocument,
@@ -1724,8 +2070,9 @@ export {
   MARGIN_PRESETS,
   MAX_LIST_LEVEL,
   PAGE_PRESETS,
+  SOFER_MIME,
   TRACKED_ORIGINS,
-  Y2 as Y,
+  Y3 as Y,
   cellsInRect,
   clearRectCells,
   collapsedSelection,
@@ -1733,20 +2080,25 @@ export {
   createBlock,
   createCell,
   createTableBlock,
+  decodeSelection,
   dedentList,
   defaultAttrsFor,
   deleteBackward,
   deleteForward,
+  deleteSelection,
   deleteTable,
   deleteTableColumn,
   deleteTableRow,
   deltaLength,
   detectPreset,
+  encodeSelection,
   expandTableRect,
+  getBlockId,
   getMarksInRange,
   indentList,
   insertImage,
   insertParagraph,
+  insertSlice,
   insertTable,
   insertTableColumn,
   insertTableRow,
@@ -1761,19 +2113,25 @@ export {
   mergeRight,
   mergeSelection,
   mmToPx,
+  moveEmbedAnchor,
   moveToNextCell,
   moveToPrevCell,
+  newBlockId,
   orderedRange,
   positionsEqual,
   pxToMm,
   removeMark,
   sameTextRun,
+  serializeSelection,
   setBlockAttr,
   setBlockType,
+  setCellAttr,
   setColumnWidth,
   setImageAttrs,
   setMark,
   sliceDelta,
+  sliceToInlineDelta,
+  sliceToText,
   spanOf,
   splitCell,
   splitListItem,