@nerd-bible/wordgard 0.3.6 → 0.5.2-beta2

package/dist/history.js

@@ -3,7 +3,15 @@ import { ChangeSet } from 'wordgard/doc';
 import { Command, undo as undo$1, redo as redo$1, Menu } from 'wordgard/command';
 import { phrases } from 'wordgard/phrases';
 
-const fromHistory = /*@__PURE__*/Transaction.Annotation.define();
+const fromHistory = /*@__PURE__*/Transaction.Effect.define({
+    map(value, change) {
+        return {
+            side: value.side,
+            startDoc: change.apply(value.startDoc),
+            rest: !value.rest ? null : value.rest.addMapping(change, value.startDoc)
+        };
+    }
+});
 const historyConfig = /*@__PURE__*/GardState.Facet.define({
     combine(configs) {
         return GardState.Facet.combineConfig(configs, {
@@ -23,13 +31,13 @@ const historyField_ = /*@__PURE__*/GardState.Field.define({
     },
     update(state, tr) {
         let config = tr.state.facet(historyConfig);
-        let fromHist = tr.annotation(fromHistory);
+        let fromHist = tr.effects.find(e => e.is(fromHistory));
         if (fromHist) {
-            let from = fromHist.side, event = eventFromTransaction(tr);
-            let other = from == 0 ? state.undone : state.done;
+            let { side, rest } = fromHist.value, event = eventFromTransaction(tr);
+            let other = side == 0 ? state.undone : state.done;
             if (event)
                 other = new Branch(event.changes, event.effects, null, tr.startState.selection, other);
-            return new HistoryState(from == 0 ? fromHist.rest : other, from == 0 ? other : fromHist.rest);
+            return new HistoryState(side == 0 ? rest : other, side == 0 ? other : rest);
         }
         let isolate = tr.annotation(history.isolate);
         if (isolate == true || isolate == "before")
@@ -239,8 +247,7 @@ class HistoryState {
         return {
             changes: branch.changes,
             selection: branch.startSelection,
-            effects: branch.effects,
-            annotations: fromHistory.of({ side, rest: branch.next }),
+            effects: branch.effects.concat(fromHistory.of({ side, startDoc: branch.changes.apply(state.doc), rest: branch.next })),
             userEvent: side == 0 ? "undo" : "redo",
             scrollIntoView: true
         };

package/dist/schema.js

@@ -1290,7 +1290,7 @@ function computeLinkTooltip(state) {
     if (!state.selection.isCursor)
         return null;
     let { head } = state.sel, before = head.nodeBefore, link = before && Link.isInSet(before.marks);
-    if (!link)
+    if (!link || head.matchingParent(plot => state.isAtom(plot.type)))
         return null;
     let start = head.pos - before.length, end = head.pos, siblings = head.parent.node.content;
     for (let index = head.index - 1; index > 0 && link.isInSet(siblings[index - 1].marks);)

package/dist/state.d.ts

@@ -151,9 +151,7 @@ declare abstract class GardSelection {
     Find the next normal cursor position after or before this selection's
     head. Normal cursor positions are:
     
-    - Any inline position, except one directly inside of an inline
-      plot that doesn't have {@link Plot.Spec.cursorInsideBounds
-      `cursorInsideBounds`} set.
+    - Any inline position.
     
     - Positions between two cursor barriers, if not already an
       inline position. Cursor barriers are the sides of the

package/dist/state.js

@@ -384,19 +384,11 @@ class TextblockMap {
                         sectionPos = pos + ch.length;
                     }
                 }
-                else if (ch.type.cursorInsideBounds) {
+                else {
                     text += " ";
                     scan(ch, pos + 1);
                     text += " ";
                 }
-                else {
-                    flush(pos);
-                    sections.push((1 << 2) | 3);
-                    scan(ch, sectionPos = pos + 1);
-                    flush(pos + ch.length - 1);
-                    sections.push((1 << 2) | 2);
-                    sectionPos = pos + ch.length;
-                }
                 pos += ch.length;
             }
         };
@@ -759,11 +751,11 @@ function cursorAtStart(cx, block) {
 }
 function isBarrier(cx, node) {
     if (node.isLeaf)
-        return node.type.isBlock;
+        return node.isBlock;
     let override = node.type.spec.cursorBarrier;
     if (override != null)
         return override;
-    return node.type.isBlock && (node.type.isolating || node.type.preserveWhitespace || cx.config.isAtom(node.type));
+    return node.isBlock && (node.type.isolating || node.type.preserveWhitespace || cx.config.isAtom(node.type));
 }
 function scanNormalFrom(cx, from, side, forward) {
     let pos = cx.doc.resolve(from), pastBarrier = false;
@@ -852,26 +844,24 @@ function findNormalAt(cx, pos, bias) {
     for (let pass = 0; pass < 2; pass++) {
         let dir = !pass ? bias : -bias, { parent, index } = res, curPos = pos;
         for (;;) {
-            if (parent.node.inlineContent &&
-                (parent.node.type.isBlock || curPos > parent.start && curPos < parent.end || parent.node.type.cursorInsideBounds))
+            if (parent.node.inlineContent)
                 return { pos: curPos, side: bias };
             if (index == (dir > 0 ? parent.node.content.length : 0)) {
-                if ((parent.node.type.isInline ? parent.node.type.cursorInsideBounds : isBarrier(cx, parent.node)) ||
-                    !parent.parent)
+                if (isBarrier(cx, parent.node) || !parent.parent)
                     break;
                 lowest = curPos = curPos + dir;
                 index = parent.index + (dir > 0 ? 1 : 0);
                 parent = parent.parent;
             }
             else {
-                let next = parent.node.content[index + (dir > 0 ? 0 : -1)];
+                let nextIndex = index + (dir > 0 ? 0 : -1), next = parent.node.content[nextIndex];
                 if (next.isLeaf || isBarrier(cx, next))
                     break;
                 if (!parent.node.inlineContent && next.inlineContent && cx.config.visualCursorMotion) {
                     let startPos = curPos - (dir > 0 ? 0 : next.length) + 1;
                     return TextblockMap.get(cx, startPos, next).visualSide(dir > 0);
                 }
-                parent = Pos.Plot.create(parent, next, curPos, index);
+                parent = Pos.Plot.create(parent, next, curPos, nextIndex);
                 index = dir > 0 ? 0 : next.content.length;
                 curPos += dir;
             }

package/dist/table.js

@@ -205,10 +205,11 @@ function computeMap(table) {
         }
         pos++;
     }
-    for (let row = 0, i = width; row < height; row++, i += width) {
+    for (let row = 0, i = 0; row < height; row++) {
         let missing = 0;
-        while (missing < width && map[i - missing - 1] == 0)
-            missing++;
+        for (let col = 0; col < width; col++)
+            if (map[i++] == 0)
+                missing++;
         if (missing)
             (problems || (problems = [])).push({ type: "missing", row, n: missing });
     }

package/dist/types.d.ts

@@ -1,5 +1,10 @@
 import { Mark, Plot, Leaf } from 'wordgard/doc';
 
+/**
+A hard line break. Renders as `<br>` and has the {@link
+Node.Role.LineBreak | `LineBreak`} role.
+*/
+declare const LineBreak: Leaf<null>;
 /**
 A paragraph. Part of the {@link Node.Group.Content | `Content`}
 group, allowing inline content, rendered as `<p>`.
@@ -58,11 +63,6 @@ A horizontal separator. Part of the {@link Node.Group.Content |
 */
 declare const HorizontalRule: Leaf<null>;
 /**
-A hard line break. Renders as `<br>` and has the {@link
-Node.Role.LineBreak | `LineBreak`} role.
-*/
-declare const LineBreak: Leaf<null>;
-/**
 Table cell plot. Allows inline content, and is in the {@link
 Node.Group.TableCell | `TableCell`} group. Rendered as `<td>`
 */

package/dist/types.js

@@ -1,6 +1,12 @@
-import { Node, Plot, Elt, ValidationError, Mark, Leaf, parse } from 'wordgard/doc';
+import { Node, Leaf, Plot, Elt, ValidationError, Mark, parse } from 'wordgard/doc';
 
 const G = /*@__PURE__*/(() => Node.Group)();
+const LineBreak = /*@__PURE__*/(() => Leaf.define("LineBreak", {
+    inline: true,
+    role: Node.Role.LineBreak,
+    toText: () => "\n",
+    shape: { element: "br" }
+}))();
 const Paragraph = /*@__PURE__*/(() => Plot.define("Paragraph", {
     inlineContent: true,
     group: G.Content,
@@ -27,7 +33,7 @@ const Heading = /*@__PURE__*/(() => Plot.Type.define("Heading", {
     ]
 }))();
 const CodeBlock = /*@__PURE__*/(() => Plot.define("CodeBlock", {
-    inlineContent: true,
+    inlineContent: [Leaf.Text, LineBreak],
     group: G.Content,
     role: Node.Role.Code,
     shape: { element: "pre" },
@@ -81,12 +87,6 @@ const HorizontalRule = /*@__PURE__*/(() => Leaf.define("HorizontalRule", {
     toText: () => "---",
     selectable: true
 }))();
-const LineBreak = /*@__PURE__*/(() => Leaf.define("LineBreak", {
-    inline: true,
-    role: Node.Role.LineBreak,
-    toText: () => "\n",
-    shape: { element: "br" }
-}))();
 const Cell = /*@__PURE__*/(() => Plot.define("Cell", {
     inlineContent: true,
     group: G.TableCell,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerd-bible/wordgard",
-  "version": "0.3.6",
+  "version": "0.5.2-beta2",
   "description": "Semantic rich text editor system",
   "type": "module",
   "main": "dist/index.js",