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

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * as editor from "wordgard/editor"
 export * as history from "wordgard/history"
 export * as phrases from "wordgard/phrases"
 export * as schema from "wordgard/schema"
+export * as set from "wordgard/set"
 export * as state from "wordgard/state"
 export * as table from "wordgard/table"
 export * as types from "wordgard/types"

package/dist/index.js

@@ -5,6 +5,7 @@ export * as editor from "wordgard/editor"
 export * as history from "wordgard/history"
 export * as phrases from "wordgard/phrases"
 export * as schema from "wordgard/schema"
+export * as set from "wordgard/set"
 export * as state from "wordgard/state"
 export * as table from "wordgard/table"
 export * as types from "wordgard/types"

package/dist/schema.js

@@ -4,7 +4,7 @@ import { Paragraph, Heading, Direction, Blockquote, HorizontalRule, Alignment, D
 import { phrases, imagePhrases, colorNames } from 'wordgard/phrases';
 import { Command, setTextblockType, Menu, setAlignment, setDirection, toggleBlock, listIsActive, toggleList, enter, toggleMark } from 'wordgard/command';
 import { history } from 'wordgard/history';
-import { KeyBinding, InputRule, Wordgard, Widget, Decoration, Panel, Dialog, PointSet, Tooltip } from 'wordgard/editor';
+import { KeyBinding, InputRule, Wordgard, Widget, Decoration, Panel, Dialog, Tooltip } from 'wordgard/editor';
 import cr from 'crelt';
 
 function blockDoc() {
@@ -827,17 +827,17 @@ const handleElt = /*@__PURE__*/(() => Elt.mk("svg:svg", { class: "wg-resize-hand
 ]))();
 const resizeWrapper = /*@__PURE__*/(() => Decoration.Point.wrapper(Elt.mk("span", { class: "wg-resize-hover" }, [handleElt, 0]), { target: "img" }))();
 const resizeState = /*@__PURE__*/GardState.Field.define({
-    create: () => ({ target: -1, resizing: -1, deco: PointSet.empty }),
+    create: () => ({ target: -1, resizing: -1, deco: Decoration.Point.none }),
     update: (value, tr) => {
         for (let e of tr.effects) {
             if (e.is(setResizing)) {
                 let { target, resizing } = e.value;
                 if (target < 0)
-                    return { target: -1, resizing: -1, deco: PointSet.empty };
-                let deco = [[target, resizeWrapper]];
+                    return { target: -1, resizing: -1, deco: Decoration.Point.none };
+                let deco = [[resizeWrapper, target]];
                 if (resizing > -1)
-                    deco.push([target, Decoration.Point.attributes({ style: `width: ${resizing}px` }, { target: "img" })]);
-                return { target, resizing, deco: PointSet.create(deco) };
+                    deco.push([Decoration.Point.attributes({ style: `width: ${resizing}px` }, { target: "img" }), target]);
+                return { target, resizing, deco: Decoration.Point.set(deco) };
             }
         }
         return value.target < 0 || !tr.docChanged ? value

package/dist/set.d.ts

@@ -0,0 +1,258 @@
+import { ChangeSet } from 'wordgard/doc';
+
+/**
+The interface shared between {@link RangeSet} and {@link
+PointSet}.
+*/
+declare abstract class Set<T> {
+    /**
+    The number of values in this set.
+    */
+    abstract length: number;
+    /**
+    Returns `true` when this set is empty.
+    */
+    abstract empty: boolean;
+    /**
+    Create a cursor over this point set, starting at the given
+    position and side.
+    */
+    abstract cursor(from?: number): Set.Cursor<T>;
+    /**
+    Adjust this set's positions for a set of document changes.
+    Returns a new set with the adjusted positions. Will delete
+    values when the content around them was deleted. Optionally
+    accepts an ordered sequence of replacements, whose positions
+    should refer to the post-change document.
+    */
+    abstract map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
+    /**
+    Create an updated copy of this set.
+    */
+    abstract modify(spec: {
+        /**
+        If given, replace all values in these ranges.
+        */
+        replace?: readonly Set.Replacement<T>[];
+        /**
+        Add values from this source.
+        */
+        add?: Set.Source<T>;
+        /**
+        Optionally filter out any value where this predicate returns
+        false.
+        */
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
+}
+declare namespace Set {
+    /**
+    A cursor over a point or range set.
+    */
+    interface Cursor<T> {
+        /**
+        The value of the current range or point, or `null` when there
+        are no more values.
+        */
+        value: T | null;
+        /**
+        The start position of the current range or point.
+        */
+        from: number;
+        /**
+        The end position of the current range. Will be equal to `from`
+        for points.
+        */
+        to: number;
+        /**
+        Move the cursor to a given position.
+        */
+        goto(pos: number, side?: number): void;
+        /**
+        Continue to the next value, if any.
+        */
+        next(): void;
+        /**
+        The set object that the current value points at, if any.
+        */
+        set: any;
+    }
+    /**
+    A source, used to create or extend a set, is either
+    an array of `[value, pos, pos?]` tuples, or a function that calls its
+    argument to add a value.
+    
+    For ranges, `to` must be given, and ranges must be provided
+    ordered by start position. For points, `to` must be omitted or
+    be the same as `from`, and the points must be ordered by
+    position and {@link PointSet.Value.side side}.
+    */
+    type Source<T> = Iterable<[T, number, number?]> | ((add: (value: T, pos: number, to?: number) => void) => void);
+    /**
+    Represents a replaced section in a set.
+    */
+    type Replacement<T> = {
+        /**
+        The start of the replacement.
+        */
+        from: number;
+        /**
+        The end of the replaced range.
+        */
+        to: number;
+        /**
+        An optional source of points to to this section.
+        */
+        add?: Source<T>;
+    };
+}
+
+/**
+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> extends Set<T> {
+    private constructor();
+    /**
+    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: Set.Source<T>): RangeSet<T>;
+    get length(): number;
+    get empty(): boolean;
+    cursor(from?: number): Set.Cursor<T>;
+    /**
+    Create a cursor over a collection of range sets.
+    */
+    static cursor<T extends RangeSet.Value>(sets: readonly RangeSet<T>[], from?: number): Set.Cursor<T>;
+    map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
+    private mapInner;
+    modify(spec: {
+        replace?: readonly Set.Replacement<T>[];
+        add?: Set.Source<T>;
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
+    private modifyInner;
+    /**
+    Compare a section of this set with a section of the same length
+    in another set. Calls `change` for any range where the two do
+    not contain identical ranges.
+    */
+    compareRange(fromA: number, b: RangeSet<T>, fromB: number, len: number, change: (from: number, to: number) => void): void;
+    /**
+    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;
+    }
+}
+
+/**
+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> implements Set<T> {
+    private constructor();
+    /**
+    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: Set.Source<T>): PointSet<T>;
+    get length(): number;
+    get empty(): boolean;
+    /**
+    Create a cursor over this point set, starting at the given
+    position and side.
+    */
+    cursor(from?: number, side?: number): Set.Cursor<T>;
+    /**
+    Create a cursor over a collection of point sets.
+    */
+    static cursor<T extends PointSet.Value>(sets: readonly PointSet<T>[], from?: number, side?: number): Set.Cursor<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;
+    /**
+    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. Optionally accepts an ordered sequence
+    of replacements.
+    */
+    map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
+    private mapInner;
+    modify(spec: {
+        replace?: readonly Set.Replacement<T>[];
+        add?: Set.Source<T>;
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
+    private modifyInner;
+    /**
+    Compare a range in this set with a range in another set. Call
+    `change` for every point that exists in one but not the other.
+    */
+    compareRange(fromA: number, b: PointSet<T>, fromB: number, len: number, change: (pos: number, value: T) => void): void;
+    /**
+    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, and to determine cursor position relative to
+        the points. Points with side < 0 are always displayed before a
+        cursor at their position, those with side > 0 always after, and
+        those with side == 0 before or after depending on the cursor's
+        side.
+        */
+        side: number;
+        /**
+        Configures 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.
+        */
+        eq(other: Value): boolean;
+    }
+}
+
+/**
+Perform a binary search on the given array (starting at start) and
+return the index of the first element > n (or the length if no
+such element exists) @hidden
+*/
+declare function findAbove(array: readonly number[], start: number, n: number): number;
+
+export { PointSet, RangeSet, Set, findAbove };