@nerd-bible/wordgard 0.6.2-beta1 → 0.6.2-beta2

package/dist/editor.js

@@ -517,7 +517,6 @@ const globalDecoFacets = [tagShape, tagWidget, tagWrapper, tagAttribute, markSha
 function findChangedRanges(prevState, prevDeco, state, deco, sections) {
     let result = [];
     let globalChange = globalDecoFacets.some(facet => prevState.facet(facet) !== state.facet(facet));
-    let shapeChanges = [];
     for (let i = 0, posA = 0, posB = 0; i < sections.length;) {
         let len = sections[i++], ins = sections[i++];
         if (ins == -1 && globalChange) {
@@ -540,11 +539,6 @@ function findChangedRanges(prevState, prevDeco, state, deco, sections) {
             compareDecoSet(prevDeco.points, deco.points, (a, b) => {
                 (a || PointSet.empty).compareRange(posA, b || PointSet.empty, posB, len, (pos, val) => {
                     add(pos, Math.min(pos + (val instanceof WidgetDecoration ? 0 : 1), endB));
-                    if (val instanceof ShapeDecoration && !globalChange) {
-                        let idx = findAbove(shapeChanges, 0, pos - 1);
-                        if (idx == shapeChanges.length || shapeChanges[idx] != pos)
-                            shapeChanges.splice(idx, 0, pos);
-                    }
                 });
             });
             let joined = joinRanges(ranges), pos = posB, end = pos + len, j = 0;
@@ -573,34 +567,8 @@ function findChangedRanges(prevState, prevDeco, state, deco, sections) {
             addSection(result, len, ins);
         }
     }
-    if (shapeChanges.length)
-        return addAtomicityChanges(result, prevState, shapeChanges);
     return result;
 }
-function addAtomicityChanges(changes, prev, nodes) {
-    let added = [];
-    let scan = prev.doc.resolve(0), sectionPos = 0, sectionI = 0, off = 0;
-    for (let posB of nodes) {
-        while (posB >= sectionPos) {
-            let len = changes[sectionI++], ins = changes[sectionI++];
-            if (ins < 0) {
-                sectionPos += len;
-            }
-            else {
-                sectionPos += ins;
-                off += len - ins;
-            }
-        }
-        let posA = posB - off;
-        if (scan.pos < posA)
-            scan = scan.advance(posA - scan.pos);
-        let node = scan.nodeAfter;
-        if (!node)
-            continue;
-        added.push(posA, posA + node.length);
-    }
-    return added.length ? addUpdated(changes, added) : changes;
-}
 class SpanIterator {
     ranges;
     points;
@@ -756,7 +724,7 @@ class DecoIterator {
         let pos = this.pos.advance(from - this.pos.pos), started = inclusiveStart;
         let atomParent;
         for (let p = pos.parent; p; p = p.parent)
-            if (this.state.isAtom(p.node.type))
+            if (!p.node.isDoc && (this.state.isAtom(p.node.type) || this.hasAtomShape(p.before)))
                 atomParent = p;
         let pendingDeco = [], pendingPos = -1;
         let pendingShape = null, pendingShapeSet = null;
@@ -892,6 +860,15 @@ class DecoIterator {
         }
         return shape;
     }
+    atomCache = new Map();
+    hasAtomShape(pos) {
+        let has = this.atomCache.get(pos);
+        if (has == null) {
+            has = this.pointSets.some(s => s.at(pos, d => d instanceof ShapeDecoration && !d.shape.hasContent));
+            this.atomCache.set(pos, has);
+        }
+        return has;
+    }
 }
 function compareSetPrec(setA, setB, array) {
     if (setA != setB)
@@ -1563,8 +1540,7 @@ class DocTile extends CompositeTile {
                     builder.update(0, true);
             }
             else if (ins == -1) {
-                builder.keep(len, !startCovered, i == changes.length);
-                startCovered = false;
+                startCovered = builder.keep(len, !startCovered, i == changes.length);
             }
             else if (ins == -2) {
                 builder.update(len, !startCovered);
@@ -2043,11 +2019,9 @@ class ContentUpdate {
                 if (span) {
                     this.new = span;
                 }
-                else {
-                    this.reused.set(tile, 2);
-                    let inner = EltTile.of(tile.elt, tile.tag, tile.flags, tile.boundary * 2, tile.dom);
-                    this.new.addChild(inner);
-                    this.new = inner;
+                else if (!tile.isNodeInner) {                    let copy = this.copyEltStructure(tile);
+                    this.new.addChild(copy);
+                    this.new = copy.contentTile;
                 }
             },
             leave: tile => {
@@ -2071,7 +2045,8 @@ class ContentUpdate {
                 }
             },
             skip: (tile, from, to) => {
-                if (!(tile instanceof TextTile)) {
+                if (tile.isNodeInner) ;
+                else if (!(tile instanceof TextTile)) {
                     if (!from && to == tile.length) {
                         this.reused.set(tile, 1);
                         this.new.addChild(tile);
@@ -2113,6 +2088,20 @@ class ContentUpdate {
         };
     }
     keep(len, includeStart, includeEnd) {
+        if (!!this.partialNode != (this.old.tile.isAtom && !this.old.tile.isText)) {
+            let dist = Math.min(len, this.partialNode
+                ? this.state.doc.nodeAt(this.posB - this.partialNode.length).length - this.partialNode.length
+                : this.old.tile.length - this.old.index);
+            this.replace(dist, dist, includeStart);
+            if (dist == len)
+                return true;
+            includeStart = false;
+            len -= dist;
+        }
+        this.keepCheckEnd(len, includeStart, includeEnd);
+        return includeEnd;
+    }
+    keepCheckEnd(len, includeStart, includeEnd) {
         let cut = [], end = this.posB + len;
         if (this.deco.endWidgets)
             for (let nw = this.new, { tile, index, parent } = this.old, pos = this.posB; pos < end;) {
@@ -2387,6 +2376,16 @@ class ContentUpdate {
             return tile;
         }
     }
+    copyEltStructure(tile) {
+        this.reused.set(tile, 2);
+        let copy = EltTile.of(tile.elt, tile.tag, tile.flags, tile.boundary * 2, tile.dom);
+        if (tile.isNodeOuter)
+            for (let child of tile.children)
+                if (child.isNodeInner) {
+                    copy.addChild((child.flags & 1024) ? this.copyEltStructure(child) : child);
+                }
+        return copy;
+    }
     ensureHackNode() {
         let tile = this.new;
         if (!tile.isPlotContent)
@@ -3390,7 +3389,14 @@ class DOMObserver {
                 return null;
             }
             else if (tile.dom == record.target) {
-                return [tile.posBefore, tile.posAfter];
+                if (!tile.isNodeInner)
+                    return [tile.posBefore, tile.posAfter];
+                while (tile.parent && tile.isNodeInner)
+                    tile = tile.parent;
+                if (tile.isDoc)
+                    return null;
+                let nodePos = tile.posBefore;
+                return [nodePos, nodePos + 1];
             }
             else {
                 return childRange(tile, record);

package/dist/set.d.ts

@@ -195,9 +195,10 @@ declare class PointSet<T extends PointSet.Value> implements Set<T> {
     /**
     Get the value at the given position, if any. If there's multiple
     values at that position, the one with the lowest side is
-    returned.
+    returned. If a predicate is given, only points that satisfy it
+    are returned.
     */
-    at(pos: number): T | undefined;
+    at(pos: number, pred?: (value: T) => boolean): T | undefined;
     /**
     Adjust the points for a set of document changes. Returns a new
     set with the adjusted points. May delete points when the content

package/dist/set.js

@@ -556,15 +556,16 @@ class PointSet {
                 cursors.push(set.cursor(from, side));
         return cursors.length == 0 ? PointSet.empty.cursor() : cursors.length == 1 ? cursors[0] : new HeapCursor(cmpCursor, cursors);
     }
-    at(pos) {
+    at(pos, pred) {
         for (let chunk of this.chunks) {
             if (chunk.start > pos)
                 break;
             if (chunk.end < pos)
                 continue;
-            let index = findAbove(chunk.pos, 0, pos - chunk.start - 1);
-            if (index < chunk.pos.length && chunk.pos[index] + chunk.start == pos)
-                return chunk.value[index];
+            for (let index = findAbove(chunk.pos, 0, pos - chunk.start - 1); index < chunk.pos.length && chunk.pos[index] + chunk.start == pos; index++) {
+                if (!pred || pred(chunk.value[index]))
+                    return chunk.value[index];
+            }
         }
         return undefined;
     }

package/package.json

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