quoin-editor 1.0.0 → 1.0.1

package/dist/yjs.js

@@ -1,172 +1,66 @@
 import {
+  applyRemote,
+  attrsMap,
   cleanEntry,
   createLayout,
+  definedEntries,
+  deleteText,
   emptySpan,
   grow,
   holdBinding,
   holdSelection,
   indexOf,
+  inlineOfOps,
+  insertInline,
+  isAtomEmbed,
+  markAttribute,
+  markerOf,
   offsetIn,
   piecesOf,
   placeEntries,
   pointOf,
+  readMarker,
+  regionNameOf,
   regionOf,
+  regionStart,
   restoreSelection,
+  sharedChange,
   spanAt,
   spanStart,
-  textLength
-} from "./chunk-TC4DARU2.js";
+  textLength,
+  textSteps,
+  writeBlock,
+  writeBlocks
+} from "./chunk-6YSGUAVW.js";
 import {
-  HISTORY_GROUP,
   HISTORY_PROVIDER,
-  addMarkStep,
   createPluginKey,
   defineExtension,
   getPluginState,
+  groupOf,
   joinBlocksStep,
-  removeMarkStep,
   replaceBlockStep,
   replaceDocStep,
-  replaceInlineStep,
   sameDoc,
-  sameSelection,
   setAttrsStep,
   setIndentStep,
-  splitBlockStep,
-  validateSelection
-} from "./chunk-HJIQT3S5.js";
+  splitBlockStep
+} from "./chunk-UPSLDTLT.js";
 import {
   sameValue
-} from "./chunk-NOKWNK2O.js";
+} from "./chunk-6LMS5J3Y.js";
 import {
-  atom,
   blockById,
   createDoc,
   equalInline,
   equalNode,
   inlineLength,
-  markKey,
-  nodeLength,
-  normalizeInline,
   sliceInline,
   text
-} from "./chunk-LCQSG4M6.js";
-
-// src/engine/collab/apply-remote.ts
-function applyRemote(editor, steps, selectionHint) {
-  const tr = editor.createTransaction().setOrigin("remote").setMeta("addToHistory", false);
-  for (const step of steps) tr.step(step);
-  if (selectionHint && sameSelection(validateSelection(tr.doc, editor.schema, selectionHint), selectionHint)) {
-    tr.setSelection(selectionHint);
-  }
-  editor.dispatch(tr);
-}
-
-// src/yjs/local-to-yjs.ts
-import * as Y4 from "yjs";
-
-// src/yjs/doc-shape.ts
-import * as Y from "yjs";
-
-// src/yjs/marks-codec.ts
-var ESCAPE = "$";
-var escapeKey = (key) => key in Object.prototype || key.startsWith(ESCAPE) ? ESCAPE + key : key;
-var unescapeKey = (key) => key.startsWith(ESCAPE) ? key.slice(1) : key;
-var onlyString = (attrs, key) => Object.keys(attrs).length === 1 && Object.hasOwn(attrs, key) && typeof attrs[key] === "string";
-function markAttribute(mark) {
-  const key = markKey(mark);
-  const { attrs } = mark;
-  const stacked = key !== mark.type;
-  if (attrs === void 0) return [escapeKey(key), !stacked];
-  if (stacked && onlyString(attrs, "id")) return [escapeKey(key), true];
-  if (onlyString(attrs, mark.type)) return [escapeKey(key), attrs[mark.type]];
-  return [escapeKey(key), attrs];
-}
-function stackedType(key) {
-  const colon = key.indexOf(":");
-  if (colon < 1) return null;
-  const type = key.slice(0, colon);
-  const id = key.slice(colon + 1);
-  return markKey({ type, attrs: { id } }) === key ? [type, id] : null;
-}
-function markFromAttribute(attribute, value) {
-  const key = unescapeKey(attribute);
-  const stacked = stackedType(key);
-  const type = stacked?.[0] ?? key;
-  if (value === true) return stacked === null ? { type } : { type, attrs: { id: stacked[1] } };
-  if (value === false) return { type };
-  if (typeof value === "string") return { type, attrs: { [type]: value } };
-  return { type, attrs: value };
-}
-var marksToAttributes = (marks) => Object.fromEntries(marks.map(markAttribute));
-var attributesToMarks = (attributes = {}) => Object.entries(attributes).map(([key, value]) => markFromAttribute(key, value));
-
-// src/yjs/inline-codec.ts
-var inlineOps = (inline) => inline.map((node) => ({
-  insert: node.kind === "text" ? node.text : { atom: node.type, attrs: node.attrs },
-  attributes: marksToAttributes(node.marks)
-}));
-function insertInline(target, at, inline) {
-  let offset = at;
-  for (const node of inline) {
-    const attributes = marksToAttributes(node.marks);
-    if (node.kind === "text") target.insert(offset, node.text, attributes);
-    else target.insertEmbed(offset, { atom: node.type, attrs: node.attrs }, attributes);
-    offset += nodeLength(node);
-  }
-}
-function nodeOf({ insert, attributes }) {
-  const marks = attributesToMarks(attributes);
-  return typeof insert === "string" ? text(insert, marks) : atom(insert.atom, insert.attrs, marks);
-}
-var inlineOfOps = (ops) => normalizeInline(ops.map(nodeOf));
-
-// src/yjs/doc-shape.ts
-var deleteText = (text2, at, length) => text2.applyDelta(at > 0 ? [{ retain: at }, { delete: length }] : [{ delete: length }]);
-var regionStart = (name) => ({ r: name });
-var isPlainObject = (value) => typeof value === "object" && value !== null && !(value instanceof Y.AbstractType);
-var regionNameOf = (embed) => isPlainObject(embed) && typeof embed.r === "string" && embed.atom === void 0 ? embed.r : null;
-var isAtomEmbed = (embed) => isPlainObject(embed) && typeof embed.atom === "string" && isPlainObject(embed.attrs);
-var definedEntries = (attrs) => Object.entries(attrs).filter(([, value]) => value !== void 0);
-function markerOf(block) {
-  return new Y.Map([
-    ["id", block.id],
-    ["type", block.type],
-    ["indent", block.indent],
-    ["attrs", new Y.Map(definedEntries(block.attrs))]
-  ]);
-}
-function readMarker(map) {
-  const [id, type, indent, attrs] = ["id", "type", "indent", "attrs"].map((key) => map.get(key));
-  if (typeof id !== "string") return null;
-  return {
-    id,
-    type: typeof type === "string" ? type : "",
-    indent: typeof indent === "number" ? indent : 0,
-    attrs: attrs instanceof Y.Map ? attrs : null
-  };
-}
-function blockOps(block, map, open) {
-  const ops = [{ insert: map, attributes: {} }];
-  for (const [name, inline] of Object.entries(block.regions)) {
-    ops.push({ insert: regionStart(name), attributes: {} });
-    if (name === open) break;
-    ops.push(...inlineOps(inline));
-  }
-  return ops;
-}
-var writeOps = (text2, at, ops) => text2.applyDelta(at > 0 ? [{ retain: at }, ...ops] : ops);
-function writeBlock(text2, at, block, map, open) {
-  writeOps(text2, at, blockOps(block, map, open));
-}
-function writeBlocks(text2, at, blocks) {
-  const maps = blocks.map(markerOf);
-  writeOps(text2, at, blocks.flatMap((block, i) => blockOps(block, maps[i])));
-  return maps;
-}
+} from "./chunk-62WKUAQY.js";
 
 // src/yjs/read-shared.ts
-import * as Y2 from "yjs";
+import * as Y from "yjs";
 
 // src/yjs/required-regions.ts
 var noRequiredRegions = () => [];
@@ -242,14 +136,22 @@ function reader(required) {
     }
   }
   function embed(value) {
-    const name = regionNameOf(value);
+    let name = regionNameOf(value);
     stray = null;
-    if (name !== null && entry !== null && !entry.regions.some((region2) => region2.name === name)) {
-      const region2 = { name, entry, segs: [] };
-      entry.regions.push(region2);
-      order.push(region2);
-      open = opened(region2);
-      return;
+    const missing = (one) => !entry.regions.some((region2) => region2.name === one);
+    if (name !== null && entry !== null) {
+      const needed = required(markers.get(entry).type);
+      if (needed.length > 0 && !needed.includes(name)) {
+        clean = false;
+        name = needed.find(missing) ?? null;
+      }
+      if (name !== null && missing(name)) {
+        const region2 = { name, entry, segs: [] };
+        entry.regions.push(region2);
+        order.push(region2);
+        open = opened(region2);
+        return;
+      }
     }
     clean = false;
     if (open !== null) open = opened(open.region);
@@ -263,7 +165,7 @@ function reader(required) {
         span.length += length;
         return;
       }
-      if (insert instanceof Y2.Map) marker(insert);
+      if (insert instanceof Y.Map) marker(insert);
       else embed(insert);
       span.length += 1;
     },
@@ -332,9 +234,6 @@ function openRegion(shared, { name, entry }, inline) {
   reread(shared);
 }
 
-// src/yjs/sync-block.ts
-import * as Y3 from "yjs";
-
 // src/yjs/inline-span.ts
 var units = (inline) => inline.flatMap(
   (node) => node.kind === "text" ? Array.from({ length: node.text.length }, (_, i) => text(node.text[i], node.marks)) : [node]
@@ -428,11 +327,8 @@ function removeBlock(shared, id) {
 
 // src/yjs/sync-block.ts
 function syncAttrs(map, before, after) {
-  const current = map.get("attrs");
-  if (!(current instanceof Y3.Map)) {
-    map.set("attrs", new Y3.Map(definedEntries(after)));
-    return;
-  }
+  const current = attrsMap(map, after);
+  if (current === null) return;
   const kept = new Map(definedEntries(after));
   for (const key of [...current.keys()]) if (!kept.has(key)) current.delete(key);
   for (const [key, value] of kept) if (!sameValue(before[key], value)) current.set(key, value);
@@ -451,8 +347,8 @@ function keptNames(before, after) {
 function syncRegions(shared, entry, before, after) {
   const { text: text2, layout } = shared;
   const names = Object.keys(after.regions);
-  const kept = keptNames(Object.keys(before.regions), names);
-  const queue = Object.entries(before.regions);
+  const queue = entry.regions.map(({ name }) => [name, before.regions[name]]);
+  const kept = keptNames(queue.map(([name]) => name), names);
   let at = spanStart(layout, entry.span) + 1;
   const dropGone = () => {
     while (queue.length > 0 && !kept.has(queue[0][0])) deleteText(text2, at, 1 + inlineLength(queue.shift()[1]));
@@ -593,8 +489,8 @@ function setAttrs({ shared, after, params }) {
   const id = params.block;
   const { map } = shared.layout.entries.get(id);
   const next = blockById(after, id).attrs;
-  const attrs = map.get("attrs");
-  if (!(attrs instanceof Y4.Map)) return void map.set("attrs", new Y4.Map(definedEntries(next)));
+  const attrs = attrsMap(map, next);
+  if (attrs === null) return;
   for (const key of Object.keys(params.patch)) {
     if (next[key] === void 0) attrs.delete(key);
     else attrs.set(key, next[key]);
@@ -643,14 +539,6 @@ function writeLocalSteps(shared, steps, docs) {
   });
 }
 
-// src/yjs/own-change.ts
-function ownChange(editor, steps, hint) {
-  const tr = editor.createTransaction().setOrigin("history").setMeta("addToHistory", false);
-  for (const step of steps) tr.step(step);
-  if (hint && sameSelection(validateSelection(tr.doc, editor.schema, hint), hint)) tr.setSelection(hint);
-  return tr;
-}
-
 // src/yjs/seed.ts
 function seedOrLoad(editor, text2, { origin, seed, required }) {
   const { blocks } = editor.state.doc;
@@ -666,71 +554,22 @@ function seedOrLoad(editor, text2, { origin, seed, required }) {
   return layout;
 }
 
-// src/yjs/undo-history.ts
-import * as Y5 from "yjs";
-var GROUP_DELAY = 500;
-var SELECTION = "selection";
-function groupOf(tr) {
-  if (tr.getMeta("closeHistory") === true) return null;
-  const named = tr.getMeta(HISTORY_GROUP);
-  if (named !== void 0) return named;
-  const before = tr.before.selection;
-  if (tr.origin !== "input" || before?.kind !== "text") return null;
-  return JSON.stringify([before.head.block, before.head.region]);
-}
-function undoHistory(text2, origin) {
-  const manager = new Y5.UndoManager(text2, { trackedOrigins: /* @__PURE__ */ new Set([origin]), captureTimeout: Infinity });
-  let group = null;
-  let time = 0;
-  let before = null;
-  let hint = null;
-  manager.on("stack-item-added", ({ stackItem }) => stackItem.meta.set(SELECTION, before));
-  return {
-    manager,
-    record(tr) {
-      if (!tr.docChanged) {
-        if (tr.getMeta("closeHistory") === true) group = null;
-        return;
-      }
-      const next = groupOf(tr);
-      if (next === null || next !== group || tr.time - time >= GROUP_DELAY) manager.stopCapturing();
-      group = next;
-      time = tr.time;
-      before = tr.before.selection;
-    },
-    travel(direction, editor) {
-      const stack = direction === "undo" ? manager.undoStack : manager.redoStack;
-      const item = stack.at(-1);
-      if (item === void 0) return false;
-      hint = item.meta.get(SELECTION) ?? null;
-      before = editor.state.selection;
-      group = null;
-      try {
-        return (direction === "undo" ? manager.undo() : manager.redo()) !== null;
-      } finally {
-        hint = null;
-      }
-    },
-    hint: () => hint,
-    destroy: () => manager.destroy()
-  };
-}
-
 // src/yjs/read-split-join.ts
-import * as Y6 from "yjs";
+import * as Y2 from "yjs";
 var bare = (op) => op === void 0 || op.attributes === void 0;
 function split(layout, delta, required) {
   const [at, ops] = delta[0]?.retain === void 0 ? [0, delta] : [delta[0].retain, delta.slice(1)];
   const map = ops[0]?.insert;
   const name = regionNameOf(ops[1]?.insert);
-  if (ops.length !== 2 || !(map instanceof Y6.Map) || name === null || !bare(delta[0])) return null;
+  if (ops.length !== 2 || !(map instanceof Y2.Map) || name === null || !bare(delta[0])) return null;
   const marker = readMarker(map);
   const span = spanAt(layout, at);
   if (span.entry === null || !isPlain(span.entry)) return null;
   const region2 = span.entry.regions.at(-1);
   const seg = region2?.segs[0];
   const rel = at - spanStart(layout, span);
-  if (marker === null || seg === void 0 || rel < seg.at || rel > seg.at + seg.length) return null;
+  if (marker === null || layout.entries.has(marker.id) || seg === void 0) return null;
+  if (rel < seg.at || rel > seg.at + seg.length) return null;
   if (required(marker.type).some((needed) => needed !== name)) return null;
   const { id, type, indent, attrs } = marker;
   const created = { id, type, indent, attrs: attrs?.toJSON() ?? {}, region: name, regions: {} };
@@ -760,61 +599,6 @@ function splitOrJoin(layout, delta, doc, required) {
   return step;
 }
 
-// src/yjs/text-steps.ts
-function segAt(layout, at, item) {
-  const span = spanAt(layout, at, item);
-  const rel = at - spanStart(layout, span);
-  const seg = span.segs.find((candidate) => candidate.at <= rel && rel <= candidate.at + candidate.length);
-  return seg === void 0 ? null : { seg, rel };
-}
-function formatSteps(layout, at, length, attributes) {
-  const steps = [];
-  for (let span = spanAt(layout, at, true); ; span = layout.spans[span.index + 1]) {
-    const start = spanStart(layout, span);
-    if (start >= at + length) break;
-    for (const seg of span.segs) {
-      const from = Math.max(at - start, seg.at);
-      const to = Math.min(at + length - start, seg.at + seg.length);
-      if (to <= from) continue;
-      const { entry, name } = seg.region;
-      const [first, last] = [offsetIn(seg, from), offsetIn(seg, to)];
-      for (const [key, value] of Object.entries(attributes)) {
-        const mark = markFromAttribute(key, value ?? true);
-        steps.push((value === null ? removeMarkStep : addMarkStep)(entry.id, name, first, last, mark));
-      }
-    }
-    if (span.index + 1 >= layout.spans.length) break;
-  }
-  return steps;
-}
-function textSteps(layout, delta) {
-  const steps = [];
-  let at = 0;
-  for (const op of delta) {
-    if (op.retain !== void 0) {
-      if (op.attributes !== void 0) steps.push(...formatSteps(layout, at, op.retain, op.attributes));
-      at += op.retain;
-    } else if (op.delete !== void 0) {
-      const found = segAt(layout, at, true);
-      if (found === null || found.rel + op.delete > found.seg.at + found.seg.length) return null;
-      const from = offsetIn(found.seg, found.rel);
-      const { entry, name } = found.seg.region;
-      steps.push(replaceInlineStep(entry.id, name, from, from + op.delete, []));
-      grow(layout, found.seg, found.rel, -op.delete);
-    } else {
-      const found = typeof op.insert === "string" || isAtomEmbed(op.insert) ? segAt(layout, at, false) : null;
-      if (found === null) return null;
-      const inline = inlineOfOps([op]);
-      const from = offsetIn(found.seg, found.rel);
-      const { entry, name } = found.seg.region;
-      steps.push(replaceInlineStep(entry.id, name, from, from, inline));
-      grow(layout, found.seg, found.rel, inlineLength(inline));
-      at += inlineLength(inline);
-    }
-  }
-  return steps;
-}
-
 // src/yjs/yjs-to-steps.ts
 var REREAD = new Error("reread");
 function markerSteps(shared, event, doc) {
@@ -828,12 +612,10 @@ function markerSteps(shared, event, doc) {
     if (fields.attrs !== target) return [];
     return [setAttrsStep(block.id, Object.fromEntries(keys.map((key) => [key, target.get(key)])))];
   }
-  if (keys.includes("id")) throw REREAD;
-  if (keys.every((key) => key === "indent")) return [setIndentStep(block.id, fields.indent)];
-  const { type, indent, attrs } = fields;
-  const empty = shared.layout.entries.get(block.id).regions.some((region2) => region2.segs.length === 0);
-  if (empty || shared.required(type).some((name) => !Object.hasOwn(block.regions, name))) throw REREAD;
-  return [replaceBlockStep({ ...block, type, indent, attrs: attrs?.toJSON() ?? {} })];
+  if (keys.includes("id") || keys.includes("type")) throw REREAD;
+  const { indent, attrs } = fields;
+  if (keys.every((key) => key === "indent")) return [setIndentStep(block.id, indent)];
+  return [replaceBlockStep({ ...block, indent, attrs: attrs?.toJSON() ?? {} })];
 }
 function contentSteps(shared, events, doc) {
   const textEvent = events.find((event) => event.target === shared.text);
@@ -854,7 +636,7 @@ function contentSteps(shared, events, doc) {
 function readRemote(shared, events, doc) {
   try {
     return { steps: contentSteps(shared, events, doc), structural: false };
-  } catch {
+  } catch (error) {
     const read = readShared(shared.text, shared.required);
     shared.layout = read.layout;
     const blocks = read.doc.blocks.map((block) => {
@@ -862,17 +644,19 @@ function readRemote(shared, events, doc) {
       return held2 !== void 0 && sameValue(held2, block) ? held2 : block;
     });
     const next = createDoc(blocks);
-    return { steps: sameDoc(next, doc) ? [] : [replaceDocStep(next)], structural: true };
+    const failed = error === REREAD ? void 0 : error;
+    return { steps: sameDoc(next, doc) ? [] : [replaceDocStep(next)], structural: true, failed };
   }
 }
 
 // src/yjs/binding.ts
-function bind(editor, text2, { origins, seed }) {
+function bind(editor, text2, options) {
+  const { origins, seed, onError } = options;
   const doc = text2.doc;
   const required = requiredRegions(editor.state.schema);
   const layout = seedOrLoad(editor, text2, { origin: origins.local, seed, required });
+  const history = options.history();
   const shared = { text: text2, layout, stale: false, required };
-  const history = undoHistory(text2, origins.local);
   const ours = (origin) => origin === origins.local || origin === origins.untracked;
   let held2 = null;
   const written = /* @__PURE__ */ new WeakSet();
@@ -881,13 +665,15 @@ function bind(editor, text2, { origins, seed }) {
   };
   const observer = (events, transaction) => {
     if (ours(transaction.origin)) return;
-    const { steps, structural } = readRemote(shared, events, editor.state.doc);
-    if (steps.length === 0) return;
-    if (transaction.origin !== history.manager)
-      return applyRemote(editor, steps, structural ? restoreSelection(text2, shared.layout, held2) : null);
-    const tr = ownChange(editor, steps, history.hint());
-    written.add(tr);
-    editor.dispatch(tr);
+    const { steps, structural, failed } = readRemote(shared, events, editor.state.doc);
+    if (steps.length > 0 && transaction.origin !== history.manager) {
+      applyRemote(editor, steps, structural ? restoreSelection(text2, shared.layout, held2) : null);
+    } else if (steps.length > 0) {
+      const tr = sharedChange(editor, steps, history.hint(), "history");
+      written.add(tr);
+      editor.dispatch(tr);
+    }
+    if (failed) onError(failed);
   };
   const settle = () => {
     shared.stale = false;
@@ -899,7 +685,6 @@ function bind(editor, text2, { origins, seed }) {
   text2.observeDeep(observer);
   return {
     editor,
-    history,
     shared,
     local(tr) {
       if (written.has(tr)) return;
@@ -914,18 +699,60 @@ function bind(editor, text2, { origins, seed }) {
     stop() {
       doc.off("beforeTransaction", hold);
       text2.unobserveDeep(observer);
-      history.destroy();
     }
   };
 }
 
+// src/yjs/undo-history.ts
+import * as Y3 from "yjs";
+var GROUP_DELAY = 500;
+var SELECTION = "selection";
+function undoHistory(text2, origin) {
+  const manager = new Y3.UndoManager(text2, { trackedOrigins: /* @__PURE__ */ new Set([origin]), captureTimeout: Infinity });
+  let group = null;
+  let time = 0;
+  let before = null;
+  let hint = null;
+  manager.on("stack-item-added", ({ stackItem }) => stackItem.meta.set(SELECTION, before));
+  return {
+    manager,
+    record(tr) {
+      if (!tr.docChanged) {
+        if (tr.getMeta("closeHistory") === true) group = null;
+        return;
+      }
+      const next = groupOf(tr);
+      if (next === null || next !== group || tr.time - time >= GROUP_DELAY) manager.stopCapturing();
+      group = next;
+      time = tr.time;
+      before = tr.before.selection;
+    },
+    travel(direction, editor) {
+      const stack = direction === "undo" ? manager.undoStack : manager.redoStack;
+      const item = stack.at(-1);
+      if (item === void 0) return false;
+      hint = item.meta.get(SELECTION) ?? null;
+      before = editor.state.selection;
+      group = null;
+      try {
+        return (direction === "undo" ? manager.undo() : manager.redo()) !== null;
+      } finally {
+        hint = null;
+      }
+    },
+    hint: () => hint
+  };
+}
+
 // src/yjs/index.ts
 function yjsCollaboration(options) {
   const { doc, field = "quoin", awareness, user, seed = "if-empty" } = options;
   const onError = options.onError ?? ((error) => console.error(error));
   const text2 = doc.getText(field);
   const origins = { local: { user }, untracked: {} };
+  let history;
   let binding = null;
+  let disconnects = 0;
   const collaboration = {
     doc,
     text: text2,
@@ -937,11 +764,22 @@ function yjsCollaboration(options) {
         onError(new Error("A Yjs collaboration connects one editor at a time; this editor stays unconnected."));
         return () => void 0;
       }
-      const current = bind(editor, text2, { origins, seed });
+      const current = bind(editor, text2, {
+        origins,
+        seed,
+        onError,
+        history: () => history ??= undoHistory(text2, origins.local)
+      });
       binding = current;
       return () => {
         current.stop();
         if (binding === current) binding = null;
+        const at = ++disconnects;
+        setTimeout(() => {
+          if (binding !== null || at !== disconnects) return;
+          history?.manager.destroy();
+          history = void 0;
+        }, 16);
       };
     },
     onLocalTransaction: (tr, state) => {
@@ -950,8 +788,8 @@ function yjsCollaboration(options) {
     history: {
       undo: () => binding?.travel("undo") ?? false,
       redo: () => binding?.travel("redo") ?? false,
-      canUndo: () => binding?.history.manager.canUndo() ?? false,
-      canRedo: () => binding?.history.manager.canRedo() ?? false
+      canUndo: () => binding !== null && history.manager.canUndo(),
+      canRedo: () => binding !== null && history.manager.canRedo()
     }
   };
   holdBinding(collaboration, () => binding);