@nerd-bible/wordgard 0.3.5 → 0.5.2-beta

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

@@ -136,6 +136,10 @@ declare abstract class GardSelection {
     */
     static cursor(pos: number, side?: -1 | 1, goalColumn?: number): GardSelection.Text;
     /**
+    Find a normal cursor near the given position.
+    */
+    static near(cx: GardSelection.Context, pos: number, side?: -1 | 1, goalColumn?: number): GardSelection.Text;
+    /**
     Create a text selection.
     */
     static range(anchor: number, head?: number, headSide?: -1 | 1, goalColumn?: number): GardSelection.Text;
@@ -147,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
@@ -161,18 +163,10 @@ declare abstract class GardSelection {
     */
     nextNormalCursor(cx: GardSelection.Context, forward?: boolean): GardSelection.Text | null;
     /**
-    Get a normal cursor at the start or end of this selection.
-    */
-    normalCursorAtBound(cx: GardSelection.Context, forward?: boolean): GardSelection.Text | null;
-    /**
     Move across one word starting from this selection's head.
     */
     skipWord(cx: GardSelection.Context, forward?: boolean): GardSelection.Text | null;
     /**
-    Find a normal selection near the given position.
-    */
-    static near(cx: GardSelection.Context, pos: number, bias?: -1 | 1): GardSelection.Text;
-    /**
     Find a normal selection at the start of the document or the
     given textblock.
     */

package/dist/state.js

@@ -384,19 +384,11 @@ class TextblockMap {
                         sectionPos = pos + ch.length;
                     }
                 }
-                else if (ch.type.spec.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;
             }
         };
@@ -590,6 +582,10 @@ class GardSelection {
     static cursor(pos, side, goalColumn) {
         return GardSelection.Text.createInner(pos, pos, side, goalColumn);
     }
+    static near(cx, pos, side = 1, goalColumn) {
+        let norm = findNormalAt(cx, pos, side);
+        return GardSelection.cursor(norm.pos, norm.side, goalColumn);
+    }
     static range(anchor, head, headSide, goalColumn) {
         return GardSelection.Text.createInner(anchor, head ?? anchor, headSide, goalColumn);
     }
@@ -597,23 +593,13 @@ class GardSelection {
         return GardSelection.Node.create(pos, node, goalColumn);
     }
     nextNormalCursor(cx, forward = true) {
-        let found = scanNormalFrom(cx, this.head, this.headSide, forward, true);
-        return found && GardSelection.cursor(found.pos, found.side);
-    }
-    normalCursorAtBound(cx, forward = true) {
-        let found = scanNormalFrom(cx, forward ? this.to : this.from, forward ? -1 : 1, forward, false);
+        let found = scanNormalFrom(cx, this.head, this.headSide, forward);
         return found && GardSelection.cursor(found.pos, found.side);
     }
     skipWord(cx, forward = true) {
         let found = skipWord(cx, this.head, this.headSide, forward);
         return found && GardSelection.cursor(found.pos, found.side);
     }
-    static near(cx, pos, bias = 1) {
-        let norm = scanNormalFrom(cx, pos, bias, bias > 0, false) ??
-            scanNormalFrom(cx, pos, -bias, bias < 0, false) ??
-            { pos: pos, side: -1 };
-        return GardSelection.cursor(norm.pos, norm.side);
-    }
     static atStart(cx, block) {
         return cursorAtStart(cx, block);
     }
@@ -621,7 +607,7 @@ class GardSelection {
         let found = block
             ? TextblockMap.get(cx, block.start, block.node).visualSide(false)
             : cx.doc.inlineContent ? TextblockMap.get(cx, 0, cx.doc).visualSide(false)
-                : scanNormalFrom(cx, cx.doc.length, -1, false, false) ?? { pos: cx.doc.length, side: -1 };
+                : findNormalAt(cx, cx.doc.length, -1);
         return GardSelection.cursor(found.pos, found.side);
     }
 }
@@ -760,22 +746,20 @@ function cursorAtStart(cx, block) {
     let found = block
         ? TextblockMap.get(cx, block.start, block.node).visualSide(true)
         : cx.doc.inlineContent ? TextblockMap.get(cx, 0, cx.doc).visualSide(true)
-            : scanNormalFrom(cx, 0, 1, true, false) ?? { pos: 0, side: 1 };
+            : findNormalAt(cx, 0, 1);
     return GardSelection.cursor(found.pos, found.side);
 }
 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.isolating || node.type.preserveWhitespace || node.type.isBlock && 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, mustMove) {
+function scanNormalFrom(cx, from, side, forward) {
     let pos = cx.doc.resolve(from), pastBarrier = false;
     if (pos.parent.node.inlineContent) {
-        if (!mustMove)
-            return { pos: pos.pos, side };
         let block = pos.textblockParent;
         let map = TextblockMap.get(cx, block.start, block.node);
         let next = cx.config.visualCursorMotion ? map.moveVisually(pos.pos, side, forward) : map.moveLogically(pos.pos, forward);
@@ -813,7 +797,7 @@ function scanNormalFrom(cx, from, side, forward, mustMove) {
         }
         if (index == (forward ? node.content.length : 0)) {
             let barrier = !next || isBarrier(cx, node);
-            if ((bottom != from || !mustMove) && pastBarrier && barrier)
+            if ((bottom != from) && pastBarrier && barrier)
                 return { pos: bottom, side: forward ? -1 : 1 };
             if (!next)
                 return null;
@@ -827,7 +811,7 @@ function scanNormalFrom(cx, from, side, forward, mustMove) {
         else {
             let nextNode = node.content[index - (forward ? 0 : 1)];
             let barrier = isBarrier(cx, nextNode);
-            if (pastBarrier && (bottom != from || !mustMove) && barrier)
+            if (pastBarrier && (bottom != from) && barrier)
                 return { pos: bottom, side: forward ? -1 : 1 };
             if (nextNode.isLeaf || cx.config.isAtom(nextNode.type)) {
                 index += step;
@@ -847,12 +831,50 @@ function scanNormalFrom(cx, from, side, forward, mustMove) {
         }
     }
 }
+function findNormalAt(cx, pos, bias) {
+    let res = cx.doc.resolve(pos), lowest = pos;
+    if (res.inText) {
+        let text = res.parent.node.content[res.index].tag.param;
+        let off = bias > 0 ? findClusterBreak(text, res.inText - 1) : findClusterBreak(text, res.inText + 1, false);
+        pos += off - res.inText;
+        if (off > 0 && off < text.length)
+            return { pos, side: bias };
+        res = Pos.create(res.parent, pos, res.index + (off ? 1 : 0), 0);
+    }
+    for (let pass = 0; pass < 2; pass++) {
+        let dir = !pass ? bias : -bias, { parent, index } = res, curPos = pos;
+        for (;;) {
+            if (parent.node.inlineContent)
+                return { pos: curPos, side: bias };
+            if (index == (dir > 0 ? parent.node.content.length : 0)) {
+                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)];
+                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);
+                index = dir > 0 ? 0 : next.content.length;
+                curPos += dir;
+            }
+        }
+    }
+    return { pos: lowest, side: bias };
+}
 function skipWord(cx, start, side, forward) {
     let last = null;
     for (let pos = start, visually = cx.config.visualCursorMotion;;) {
         let block = cx.doc.resolve(pos).textblockParent;
         if (!block) {
-            let next = scanNormalFrom(cx, pos, side, forward, true);
+            let next = scanNormalFrom(cx, pos, side, forward);
             if (!next)
                 return last;
             ({ pos, side } = next);

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.5",
+  "version": "0.5.2-beta",
   "description": "Semantic rich text editor system",
   "type": "module",
   "main": "dist/index.js",