@nerd-bible/wordgard 0.5.3-beta4 → 0.5.3-beta6

package/dist/doc.js

@@ -2158,43 +2158,8 @@ class ChangeSet {
         return fix ? set.compose(fix) : set;
     }
     compose(other) {
-        let sectionsA = this.sections, dataA = this.data;
-        let sectionsB = other.sections, dataB = other.data;
-        let sections = [], data = [];
-        let a = new SectionIter(sectionsA, dataA), b = new SectionIter(sectionsB, dataB);
-        for (let open = false;;) {
-            if (a.done && b.done) {
-                return new ChangeSet(sections, data);
-            }
-            else if (a.ins == 0) {                addSection(sections, data, a.len, 0, a.slice, open);
-                a.next();
-            }
-            else if (b.len == 0 && !b.done) {                addSection(sections, data, 0, b.ins, b.slice, open);
-                b.next();
-            }
-            else if (a.done || b.done) {
-                throw new ValidationError("Mismatched change set lengths");
-            }
-            else {
-                let len = Math.min(a.len2, b.len), sectionLen = sections.length;
-                if (a.keep && b.keep) {
-                    let mods = combineMods(a.mods, b.mods);
-                    addSection(sections, data, len, mods ? -2 : -1, mods, open);
-                }
-                else if (a.keep) {
-                    addSection(sections, data, len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
-                }
-                else if (b.keep) {
-                    addSection(sections, data, a.off ? 0 : a.len, len, applyModsToSlice(a.slicePart(len), b.mods), open);
-                }
-                else {
-                    addSection(sections, data, a.off ? 0 : a.len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
-                }
-                open = (a.ins > len || b.ins >= 0 && b.len > len) && (open || sections.length > sectionLen);
-                a.forward2(len);
-                b.forward(len);
-            }
-        }
+        let { sections, data } = compose(this.sections, other.sections, this.data, other.data);
+        return new ChangeSet(sections, data);
     }
     invert(doc) {
         let sections = [], data = [];
@@ -2415,6 +2380,9 @@ class ChangeSet {
         }
         return result;
     }
+    static composeSections(a, b) {
+        return compose(a, b).sections;
+    }
     static transform(doc, a, b) {
         let { set: mA, fix } = transform(a, b, doc, true, true);
         let mB = transform(b, a, doc, false, false).set;
@@ -2613,6 +2581,43 @@ function transform(setA, setB, doc, before, fit) {
         }
     }
 }
+function compose(sectionsA, sectionsB, dataA, dataB) {
+    let sections = [], data = dataA ? [] : null;
+    let a = new SectionIter(sectionsA, dataA), b = new SectionIter(sectionsB, dataB);
+    for (let open = false;;) {
+        if (a.done && b.done) {
+            return { sections, data };
+        }
+        else if (a.ins == 0) {            addSection(sections, data, a.len, 0, a.slice, open);
+            a.next();
+        }
+        else if (b.len == 0 && !b.done) {            addSection(sections, data, 0, b.ins, b.slice, open);
+            b.next();
+        }
+        else if (a.done || b.done) {
+            throw new ValidationError("Mismatched change set lengths");
+        }
+        else {
+            let len = Math.min(a.len2, b.len), sectionLen = sections.length;
+            if (a.keep && b.keep) {
+                let mods = combineMods(a.mods, b.mods);
+                addSection(sections, data, len, (data ? mods : a.ins == -2 || b.ins == -2) ? -2 : -1, mods, open);
+            }
+            else if (a.keep) {
+                addSection(sections, data, len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
+            }
+            else if (b.keep) {
+                addSection(sections, data, a.off ? 0 : a.len, len, data ? applyModsToSlice(a.slicePart(len), b.mods) : null, open);
+            }
+            else {
+                addSection(sections, data, a.off ? 0 : a.len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
+            }
+            open = (a.ins > len || b.ins >= 0 && b.len > len) && (open || sections.length > sectionLen);
+            a.forward2(len);
+            b.forward(len);
+        }
+    }
+}
 function combineMods(a, b) {
     return !a ? b : !b ? a : a.concat(b);
 }
@@ -2972,10 +2977,10 @@ class SectionIter {
     get done() { return this.ins == -3; }
     get len2() { return this.ins < 0 ? this.len : this.ins; }
     get mods() {
-        return this.data[(this.i - 2) >> 1];
+        return this.data ? this.data[(this.i - 2) >> 1] : null;
     }
     get slice() {
-        return this.data[(this.i - 2) >> 1];
+        return this.data ? this.data[(this.i - 2) >> 1] : Slice.empty;
     }
     slicePart(len) {
         return this.slice.slice(this.off, len == null ? undefined : this.off + len);
@@ -3004,7 +3009,7 @@ function addSection(sections, data, len, ins, value, forceJoin = false) {
         return;
     let last = sections.length - 2;
     if (last >= 0 && ins <= 0 && ins == sections[last + 1]) {
-        let lastValue = data[data.length - 1];
+        let lastValue = data ? data[data.length - 1] : null;
         let match = ins == 0 ? true
             : value ? lastValue && compareModifications(lastValue, value)
                 : !lastValue;
@@ -3016,11 +3021,13 @@ function addSection(sections, data, len, ins, value, forceJoin = false) {
     if (forceJoin || last >= 0 && len == 0 && sections[last] == 0) {
         sections[last] += len;
         sections[last + 1] += ins;
-        data[data.length - 1] = data[data.length - 1].concat(value);
+        if (data)
+            data[data.length - 1] = data[data.length - 1].concat(value);
     }
     else {
         sections.push(len, ins);
-        data.push(value);
+        if (data)
+            data.push(value);
     }
 }
 function finishCx(cx, schema) {

package/dist/editor.d.ts

@@ -4,6 +4,7 @@ import { GardState, TextblockMap, Transaction, GardSelection } from 'wordgard/st
 import { PhraseSet } from 'wordgard/phrases';
 import { StyleModule, StyleSpec } from 'style-mod';
 import { Command, Menu } from 'wordgard/command';
+import { PointSet, Set, RangeSet } from 'wordgard/set';
 
 type MakeSelectionStyle = (wg: Wordgard, event: MouseEvent) => Wordgard.MouseSelectionStyle | null;
 
@@ -123,7 +124,7 @@ declare namespace Decoration {
             /**
             This function allows you to define a {@link Decoration.Tag.shape
             custom node shape} that depends on the editor state. It will
-            automatically track what slots (see {@link
+            automatically track which state slots (see {@link
             GardState.Facet.compute}) you use, and make sure the nodes
             are redrawn when those change.
             
@@ -250,6 +251,21 @@ declare namespace Decoration {
         keep your set in a state field and update it incrementally.
         */
         static source: GardState.Facet<(state: GardState) => PointSet<Point>, readonly ((state: GardState) => PointSet<Point>)[]>;
+        /**
+        Create a {@link PointSet} from an array or source function of
+        point decorations.
+        */
+        static set(source: Set.Source<Point>): Point.Set;
+        /**
+        The empty set of point decorations.
+        */
+        static none: Point.Set;
+    }
+    namespace Point {
+        /**
+        The type used for sets of point decorations.
+        */
+        type Set = PointSet<Point>;
     }
     /**
     Range decorations apply to a document range. They are stored in
@@ -280,7 +296,16 @@ declare namespace Decoration {
         range sets on the fly will not perform well, so you'll often
         want to store these in a state field.
         */
-        static source: GardState.Facet<(state: GardState) => RangeSet<Range>, readonly ((state: GardState) => RangeSet<Range>)[]>;
+        static source: GardState.Facet<(state: GardState) => Range.Set, readonly ((state: GardState) => Range.Set)[]>;
+        /**
+        Create a {@link RangeSet} from an array or source function of
+        range decorations.
+        */
+        static set(source: Set.Source<Range>): Range.Set;
+        /**
+        The empty set of range decorations.
+        */
+        static none: Range.Set;
     }
     namespace Range {
         /**
@@ -324,141 +349,10 @@ declare namespace Decoration {
             */
             spanning?: boolean;
         }
-    }
-}
-/**
-Data structure used to store sets of points and then track them
-across document changes. Mostly used for {@link Decoration.Point
-point decorations}, but can also track your own types, if you make
-sure they implement the {@link PointSet.Value} interface.
-*/
-declare class PointSet<T extends PointSet.Value = PointSet.Value> {
-    /**
-    The values in this set.
-    */
-    readonly values: readonly T[];
-    /**
-    The positions of the values in this set.
-    */
-    readonly positions: readonly number[];
-    private constructor();
-    /**
-    The number of points in this set.
-    */
-    get length(): number;
-    /**
-    Adjust the points for a set of document changes. Returns a new
-    set with the adjusted points. May delete points when the content
-    around them was deleted.
-    */
-    map(changes: ChangeSet, start?: number): PointSet<T>;
-    /**
-    Returns the union of this set and the given set. If
-    `maskFrom`/`maskTo` are given, drop any points from `this`
-    between or at those positions.
-    */
-    merge(other: PointSet<T>, maskFrom?: number, maskTo?: number | undefined): PointSet<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.
-    */
-    at(pos: number): T | undefined;
-    /**
-    Create a point set from an iterable of `[position, value]`
-    tuples, or a function that calls its argument for every point to
-    add.
-    */
-    static create<T extends PointSet.Value>(source: Iterable<[number, T]> | ((add: (pos: number, value: T) => void) => void)): PointSet<T>;
-    /**
-    The empty point set.
-    */
-    static empty: PointSet<any>;
-}
-declare namespace PointSet {
-    /**
-    Objects stored in a point set must conform to this interface.
-    */
-    interface Value {
-        /**
-        The side of the point. Used to provide a sorting of points at
-        the same position
-        */
-        side: number;
-        /**
-        Specifies whether the point should be deleted when content
-        next to it is deleted. See {@link ChangeSet.mapPos}.
-        */
-        trackMode: ChangeSet.TrackMode | undefined;
         /**
-        Method to compare this value to another.
+        The type used for sets of point decorations.
         */
-        eq(other: PointSet.Value): boolean;
-    }
-}
-/**
-Data structure that stores sets of ranges, for use with {@link
-Decoration.Range range decorations} or other data types
-implementing {@link RangeSet.Value}.
-*/
-declare class RangeSet<T extends RangeSet.Value = RangeSet.Value> {
-    /**
-    The value associated with the ranges in the set.
-    */
-    readonly values: readonly T[];
-    /**
-    The start positions of the ranges in this set.
-    */
-    readonly from: readonly number[];
-    /**
-    The end positions of the ranges.
-    */
-    readonly to: readonly number[];
-    private constructor();
-    /**
-    The number of ranges stored in this set.
-    */
-    get length(): number;
-    /**
-    Adjust the positions of the ranges for the given change set.
-    Returns a set with the updated ranges.
-    */
-    map(changes: ChangeSet, start?: number): RangeSet<T>;
-    /**
-    Merge this set with another set. If `maskFrom`/`maskTo` are
-    given, any ranges overlapping the masked range in `this` are
-    not included in the merged set.
-    */
-    merge(other: RangeSet<T>, maskFrom?: number, maskTo?: number | undefined): RangeSet<T>;
-    /**
-    Create a range set from an iterable of `[from, to, value]`
-    tuples, or a function that calls its argument for every range to
-    add.
-    */
-    static create<T extends RangeSet.Value>(source: Iterable<[number, number, T]> | ((add: (from: number, to: number, value: T) => void) => void)): RangeSet<T>;
-    /**
-    The empty range set.
-    */
-    static empty: RangeSet<any>;
-}
-declare namespace RangeSet {
-    /**
-    Values stored in a range set must conform to this interface.
-    */
-    interface Value {
-        /**
-        Whether content inserted at the start of this value's range is
-        included in the range.
-        */
-        inclusiveStart: boolean;
-        /**
-        Whether content inserted at the end is included.
-        */
-        inclusiveEnd: boolean;
-        /**
-        Compare this value to another.
-        */
-        eq(other: Value): boolean;
+        type Set = RangeSet<Range>;
     }
 }
 
@@ -511,7 +405,7 @@ declare abstract class Tile {
     get isSpanning(): boolean;
     get isComposition(): boolean;
     get isPoint(): boolean;
-    get node(): Node$1 | null;
+    get tag(): Node$1.Tag | null;
     posBeforeChild(child: Tile, ownStart?: number): number;
     get posBefore(): number;
     get posAtStart(): number;
@@ -1432,6 +1326,35 @@ declare namespace KeyBinding {
     const defaultKeymap: readonly KeyBinding[];
 }
 
+type Config = {
+    /**
+    The type of plot to decorate.
+    */
+    type: Node$1.Query;
+    /**
+    A function that produces range decorations for a plot. `from`
+    and `to` should be relative to the start of the plot's content,
+    and be fall entirely within the plot.
+    */
+    ranges?: (node: Plot, range: (deco: Decoration.Range, from: number, to: number) => void) => void;
+    /**
+    A function that produces point decorations for a plot. `pos`
+    should be relative to the start of the plot's content.
+    */
+    points?: (node: Plot, point: (deco: Decoration.Point, pos: number) => void) => void;
+    /**
+    An optional function that causes the decorations to be recreated
+    on matching transaction, either for the entire document (`true`)
+    or for any plot where the returned predicate returns `true`.
+    */
+    refresh?: (tr: Transaction) => boolean | ((plot: Plot) => boolean);
+};
+/**
+Create an extension that adds decorations to plots matching the
+given type.
+*/
+declare function decoratePlots(config: Config): GardState.Extension;
+
 type PanelConfig = {
     /**
     By default, panels will be placed inside the editor's DOM
@@ -1938,4 +1861,4 @@ being dragged over the editor.
 */
 declare function dropCursor(): GardState.Extension;
 
-export { Decoration, Dialog, InputRule, KeyBinding, Panel, PointSet, RangeSet, Tooltip, Widget, Wordgard, dropCursor, menuBar, placeholder };
+export { Decoration, Dialog, InputRule, KeyBinding, Panel, Tooltip, Widget, Wordgard, decoratePlots, dropCursor, menuBar, placeholder };