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

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 };
+                    return { target: -1, resizing: -1, deco: Decoration.Point.none };
                 let deco = [[target, resizeWrapper]];
                 if (resizing > -1)
                     deco.push([target, Decoration.Point.attributes({ style: `width: ${resizing}px` }, { target: "img" })]);
-                return { target, resizing, deco: PointSet.create(deco) };
+                return { target, resizing, deco: Decoration.Point.set(deco) };
             }
         }
         return value.target < 0 || !tr.docChanged ? value

package/dist/set.d.ts

@@ -0,0 +1,305 @@
+import { ChangeSet } from 'wordgard/doc';
+
+/**
+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> {
+    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: RangeSet.Source<T>): RangeSet<T>;
+    /**
+    The number of ranges stored in this set.
+    */
+    get length(): number;
+    /**
+    Returns true when this set is empty.
+    */
+    get empty(): boolean;
+    /**
+    Create a cursor over this set, starting at the given position.
+    */
+    cursor(from?: number): RangeSet.Cursor<T>;
+    /**
+    Create a cursor over a collection of range sets.
+    */
+    static cursor<T extends RangeSet.Value>(sets: readonly RangeSet<T>[], from?: number): RangeSet.Cursor<T>;
+    /**
+    Adjust the positions of the ranges for the given change set.
+    Returns a set with the updated ranges. Optionally takes an array
+    of replacement ranges. Any ranges overlapping such a replacement
+    will be dropped, and new ranges provided by their `add`
+    properties will be added to the new set.
+    */
+    map(map: ChangeSet, replace?: readonly RangeSet.Replacement<T>[]): RangeSet<T>;
+    private mapInner;
+    /**
+    Modify this set.
+    */
+    modify(spec: {
+        /**
+        Drop any ranges inside the given replacement ranges,
+        optionally add new ranges provided by their `add` property.
+        */
+        replace?: readonly RangeSet.Replacement<T>[];
+        /**
+        Add new ranges to the set.
+        */
+        add?: RangeSet.Source<T>;
+        /**
+        Drop any range for which this predicate function returns
+        `false`.
+        */
+        filter?: (from: number, to: number, value: T) => boolean;
+    }): RangeSet<T>;
+    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;
+    }
+    /**
+    A range source, used to construct or extend a range set, must
+    either be an array of `[from, to, value]` tuples, or a function
+    that calls its argument for each range to add. Ranges must be
+    provided ordered by their `from` position.
+    */
+    type Source<T extends Value> = Iterable<[number, number, T]> | ((add: (from: number, to: number, value: T) => void) => void);
+    /**
+    Represents a replaced section in a range set.
+    */
+    type Replacement<T extends Value> = {
+        /**
+        The start of the section.
+        */
+        from: number;
+        /**
+        The end of the section.
+        */
+        to: number;
+        /**
+        An optional collection of ranges to replace the section with.
+        Must fall within `from` and `to`.
+        */
+        add?: Source<T>;
+    };
+    /**
+    A cursor over a range set.
+    */
+    interface Cursor<T extends Value> {
+        /**
+        The current range's value, or `null` if the end of the set has
+        been reached.
+        */
+        value: T | null;
+        /**
+        The start position of the current range.
+        */
+        from: number;
+        /**
+        The end position of the current range.
+        */
+        to: number;
+        /**
+        Move the cursor to a new position.
+        */
+        goto(pos: number): void;
+        /**
+        Move to the next range, if any.
+        */
+        next(): void;
+    }
+}
+
+/**
+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> {
+    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: PointSet.Source<T>): PointSet<T>;
+    /**
+    The number of points in this set.
+    */
+    get length(): number;
+    /**
+    Returns `true` when this set is empty.
+    */
+    get empty(): boolean;
+    /**
+    Create a cursor over this point set, starting at the given
+    position and side.
+    */
+    cursor(from?: number, side?: number): PointSet.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): PointSet.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 PointSet.Replacement<T>[]): PointSet<T>;
+    private mapInner;
+    /**
+    Create an updated copy of this set.
+    */
+    modify(spec: {
+        /**
+        If given, replace all points in these ranges.
+        */
+        replace?: readonly PointSet.Replacement<T>[];
+        /**
+        Add the points from this source.
+        */
+        add?: PointSet.Source<T>;
+        /**
+        Optionally filter out any point where this predicate returns
+        false.
+        */
+        filter?: (pos: number, value: T) => boolean;
+    }): PointSet<T>;
+    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;
+    }
+    /**
+    A point source, used to create or extend a point set, is either
+    an array of `[pos, value]` tuples, or a function that calls its
+    argument to add a point. Point sources must provide their points
+    ordered by position and {@link PointSet.Value.side side}.
+    */
+    type Source<T extends Value> = Iterable<[number, T]> | ((add: (pos: number, value: T) => void) => void);
+    /**
+    Represents a replaced section in a point set.
+    */
+    type Replacement<T extends Value> = {
+        /**
+        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?: PointSet.Source<T>;
+    };
+    /**
+    A cursor over a point set.
+    */
+    interface Cursor<T extends Value> {
+        /**
+        The value of the current point, or `null` when there are no
+        more points.
+        */
+        value: T | null;
+        /**
+        The position of the current point.
+        */
+        pos: number;
+        /**
+        The side value of the current point.
+        */
+        side: number;
+        /**
+        Move the cursor to a given position and side.
+        */
+        goto(pos: number, side: number): void;
+        /**
+        Continue to the next point, if any.
+        */
+        next(): void;
+        /**
+        The set object that the current point belongs to.
+        */
+        set: PointSet<T>;
+    }
+}
+
+/**
+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, findAbove };