@nerd-bible/wordgard 0.5.3-beta7 → 0.6.2-beta10

package/dist/set.js

@@ -99,6 +99,7 @@ class HeapCursor {
                 heapSink(this.heap, this.heap.length - 1, this.cmp);
             }
         }
+        this.fill();
     }
     next() {
         if (this.heap.length) {
@@ -163,7 +164,11 @@ let SetBuilder$1 = class SetBuilder {
     addRange(value, from, to) {
         if (from >= to)
             throw new Error("Ranges cannot be empty");
-        (this.lastTo <= from ? this : this.next).addInner(value, from, to);
+        for (let target = this;; target = target.next)
+            if (target.lastTo <= from) {
+                target.addInner(value, from, to);
+                break;
+            }
     }
     addInner(value, from, to) {
         let chunk;
@@ -245,13 +250,13 @@ class RangeSet extends Set {
         let replI = 0, posA = 0, posB = 0;
         let build = new SetBuilder$1();
         for (let i = 0; i < sections.length;) {
-            let len = sections[i++], ins = sections[i++];
+            let len = sections[i++], ins = sections[i++], endA = posA + len;
             if (ins < 0) {
                 while (i < sections.length && sections[i + 1] < 0) {
                     len += sections[i];
                     i += 2;
                 }
-                let upto = i == sections.length ? 1e9 : posA + len, off = posB - posA;
+                let upto = i == sections.length ? 1e9 : endA, off = posB - posA;
                 while (cursor.cur) {
                     let chunk = cursor.cur;
                     if (cursor.i == 0 && chunk.end < upto) {
@@ -276,12 +281,12 @@ class RangeSet extends Set {
                     if (repl.add)
                         build.add(repl.add);
                 }
-                if (len)
-                    cursor.goto(posA + len - 1);
-                copyMappedUpto$1(cursor, posA + len, map, build, replace, replStartI);
+                if (len && cursor.to < endA)
+                    cursor.goto(endA - 1);
+                copyMappedUpto$1(cursor, endA, map, build, replace, replStartI);
                 posB = endB;
             }
-            posA += len;
+            posA = endA;
         }
         return build.finish(this.next && this.next.mapInner(sections, map, replace));
     }
@@ -555,15 +560,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.end > pos)
-                break;
             if (chunk.start > pos)
+                break;
+            if (chunk.end < pos)
                 continue;
-            let index = findAbove(chunk.pos, 0, pos - 1);
-            if (index < chunk.pos.length && chunk.pos[index] == 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/dist/state.d.ts

@@ -1,4 +1,4 @@
-import { ChangeSet, Node, Pos, Plot, Mark, Schema } from 'wordgard/doc';
+import { Plot, Slice, ChangeSet, Node, Pos, Mark, Schema } from 'wordgard/doc';
 
 type wgNode = Node;
 /**
@@ -87,6 +87,12 @@ declare abstract class GardSelection {
         anchorSide: -1 | 1;
     };
     /**
+    Create a content slice and context from this selection. The
+    default implementation concatenates the slices for the
+    selection's `ranges`.
+    */
+    toSlice(doc: Plot.Doc): Slice;
+    /**
     The side that the selection head is associated with. -1 means it
     is after the element before its position, 1 means it is before
     the element after its position. This influences where the
@@ -144,6 +150,10 @@ declare abstract class GardSelection {
     */
     static range(anchor: number, head?: number, headSide?: -1 | 1, goalColumn?: number): GardSelection.Text;
     /**
+    Create a text selection.
+    */
+    static undirectionalRange(from: number, to: number): GardSelection.Text;
+    /**
     Create a node selection.
     */
     static node(pos: number, node: wgNode, goalColumn?: number): GardSelection.Node;
@@ -196,6 +206,13 @@ declare namespace GardSelection {
     class Text extends GardSelection {
         private _headSide;
         /**
+        When `false`, indicates that this selection may swap `head`
+        and `anchor` when extended. Used for things like selections
+        created by double-clicking, which don't have a clearly
+        defined anchor.
+        */
+        readonly directional: boolean;
+        /**
         A set of active marks that should be applied to content
         inserted at this selection (replacing the contextual marks).
         Used mostly for making the effect of toggling inline styles
@@ -248,6 +265,11 @@ declare namespace GardSelection {
             used for things like toggling emphasis on a cursor selection.
             */
             marks?: Mark.Set;
+            /**
+            Set to `false` to indicate that this selection isn't {@link
+            GardSelection.Text.directional directional}.
+            */
+            directional?: boolean;
         };
         /**
         The representation of a text selection when serialized to JSON.
@@ -256,6 +278,7 @@ declare namespace GardSelection {
             anchor: number;
             head?: number;
             side?: -1 | 1;
+            directional?: boolean;
             marks?: Record<string, any>;
         };
     }
@@ -375,6 +398,10 @@ declare class Transaction {
     */
     readonly effects: readonly Transaction.Effect<any>[];
     /**
+    The annotations on this transaction.
+    */
+    readonly annotations: readonly Transaction.Annotation<any>[];
+    /**
     Whether the selection should be scrolled into view after this
     transaction is dispatched.
     */
@@ -469,7 +496,7 @@ declare namespace Transaction {
         scrollIntoView?: boolean;
         /**
         Only meaningful for specs that are combined with another
-        transaction spec (via {@link Transaction.merge or by being
+        transaction spec (via {@link Transaction.merge} or by being
         returned from an {@link Transaction.extender extender}.
         Normally, when specs are combined, the positions in `changes`
         are taken to refer to the document positions in the initial
@@ -546,7 +573,7 @@ declare namespace Transaction {
         /**
         Define a new type of annotation.
         */
-        static define<T>(): Annotation.Type<T>;
+        static define<T>(name?: string): Annotation.Type<T>;
         private _isAnnotation;
     }
     namespace Annotation {
@@ -555,13 +582,17 @@ declare namespace Transaction {
         annotation}.
         */
         class Type<T> {
+            /**
+            This type's debug name.
+            */
+            readonly name: string | null;
+            private constructor();
             /**
             Create an instance of this annotation.
             */
             of(value: T): Transaction.Annotation<T>;
         }
     }
-    const foo: number;
     /**
     Annotation used to store transaction timestamps. Automatically
     added to every transaction, holding `Date.now()`.
@@ -665,6 +696,11 @@ declare namespace Transaction {
             */
             readonly map: (value: any, mapping: ChangeSet) => any | undefined;
             /**
+            The debug name of this effect.
+            */
+            readonly name: string | null;
+            private constructor();
+            /**
             Create an {@link Transaction.Effect effect} instance of this
             type.
             */
@@ -674,6 +710,10 @@ declare namespace Transaction {
         Options passed when defining an effect.
         */
         interface Spec<Value> {
+            /**
+            An optional debug name to assign to this effect.
+            */
+            name?: string;
             /**
             Provides a way to map an effect like this through a position
             mapping. When not given, the effects will simply not be mapped.
@@ -771,15 +811,6 @@ declare class TextblockMap {
     Get the document position for a given string index.
     */
     fromIndex(index: number): number;
-    /**
-    Get the position at the start or end of the textblock. Note that
-    in bidirectional text this may not be the actual start or end
-    position of the node.
-    */
-    visualSide(start: boolean): {
-        pos: number;
-        side: -1 | 1;
-    };
 }
 
 type DocSource = Plot.Doc | HTMLElement | DocumentFragment | string | Node.JSON | ((schema: Schema) => Plot.Doc);
@@ -834,12 +865,16 @@ declare class GardState {
     */
     get sel(): GardSelection.Resolved;
     /**
-    Retrieve the value of a {@link GardState.Field state field}.
-    Throws an error when the state doesn't have that field, unless
-    you pass `false` as second parameter.
+    Retrieve the value of a {@link GardState.Field state field} or
+    {@link GardState.Field.Derived derived field}. Throws an error
+    when the state doesn't have that field, unless you pass `false`
+    as second parameter, in which case you'll get `undefined` for a
+    regular field, or the value will be eagerly computed for a
+    derived field.
     */
-    field<T>(field: GardState.Field<T>): T;
+    field<T>(field: GardState.Field<T> | GardState.Field.Derived<T>): T;
     field<T>(field: GardState.Field<T>, require: false): T | undefined;
+    field<T>(field: GardState.Field.Derived<T>, require: false): T;
     /**
     Get the value of a state {@link GardState.Facet facet}.
     */
@@ -895,9 +930,9 @@ declare class GardState {
     isAtom(type: Node.Type): boolean;
     /**
     Return the extent of the word around the given position, as a
-    text selection.
+    text selection, or null if there is no word there.
     */
-    wordAt(pos: number, bias?: -1 | 1): GardSelection.Text;
+    wordAt(pos: number, bias?: -1 | 1): GardSelection.Text | null;
     /**
     This effect can be used to reconfigure the root extensions of
     the editor. Doing this will discard any extensions {@link
@@ -958,6 +993,10 @@ declare namespace GardState {
         Define a state field.
         */
         static define<Value>(config: GardState.Field.Spec<Value>): GardState.Field<Value>;
+        /**
+        The field's debugging name, if given.
+        */
+        name: string | null;
         private create;
         /**
         State field instances can be used as {@link
@@ -977,6 +1016,11 @@ declare namespace GardState {
         The options passed when defining a state field.
         */
         type Spec<Value> = {
+            /**
+            An optional name to associate with this field for debugging
+            purposes.
+            */
+            name?: string;
             /**
             Creates the initial value for the field when a state is created.
             */
@@ -1016,6 +1060,42 @@ declare namespace GardState {
             */
             fromJSON?: (json: any, state: GardState) => Value;
         };
+        /**
+        Define a field-like state slot that is computed from other
+        slots in the state. Automatically tracks dependencies and only
+        recomputes when one of the inputs accessed by the given
+        function changes. Use {@link GardState.field} to read the
+        value of such a field.
+        */
+        class Derived<Value> {
+            private compareF;
+            /**
+            This field's debugging name, if given.
+            */
+            readonly name: string | null;
+            private constructor();
+            /**
+            Define a derived field.
+            */
+            static define<Value>(compute: (state: GardState) => Value, spec?: {
+                /**
+                An optional debugging name for this field.
+                */
+                name?: string;
+                /**
+                Optional function used to compare the value of the field,
+                to prevent propagating a change when a recomputed result
+                is the same as the old value. Should return `true` when
+                the inputs can be considered the same. Defaults to `===`.
+                */
+                compare?: (a: Value, b: Value) => boolean;
+            }): Derived<Value>;
+            /**
+            Derived fields must be included in your state configuration
+            for them to be used.
+            */
+            get extension(): GardState.Extension;
+        }
     }
     /**
     A facet is a labeled value that is associated with an editor
@@ -1042,6 +1122,10 @@ declare namespace GardState {
         */
         readonly isStatic: boolean;
         /**
+        The facet's debug name.
+        */
+        readonly name: string | null;
+        /**
         The output of the facet when it has no inputs.
         */
         readonly default: Output;
@@ -1061,7 +1145,7 @@ declare namespace GardState {
         */
         of(value: Input): GardState.Extension;
         /**
-        Create an extension that computes a value for the facet from a
+        Create an extension that derives a value for the facet from a
         state. The given function should only depend on the state, not
         any external non-constant inputs. Its return value will be kept
         on state update, unless any of the fields or facets (including
@@ -1072,21 +1156,20 @@ declare namespace GardState {
         can use the {@link GardState.Facet.from `from`} method
         instead.
         */
-        compute(get: (state: GardState) => Input): GardState.Extension;
+        derive(get: (state: GardState) => Input): GardState.Extension;
         /**
-        Create an extension that computes zero or more values for this
+        Create an extension that derives zero or more values for this
         facet from a state.
         */
-        computeN(get: (state: GardState) => readonly Input[]): GardState.Extension;
+        deriveN(get: (state: GardState) => readonly Input[]): GardState.Extension;
         /**
         Shorthand method for registering a facet source with a state
         field as input. If the field's type corresponds to this facet's
         input type, the getter function can be omitted. If given, it
         will be used to produce the input from the field value.
         */
-        from<T extends Input>(field: GardState.Field<T>): GardState.Extension;
-        from<T>(field: GardState.Field<T>, get: (value: T) => Input): GardState.Extension;
-        tag: Output;
+        from<T extends Input>(field: GardState.Field<T> | GardState.Field.Derived<T>): GardState.Extension;
+        from<T>(field: GardState.Field<T> | GardState.Field.Derived<T>, get: (value: T) => Input): GardState.Extension;
     }
     namespace Facet {
         /**
@@ -1094,6 +1177,10 @@ declare namespace GardState {
         facet.
         */
         type Spec<Input, Output> = {
+            /**
+            And optional name, to recognize the facet when debugging.
+            */
+            name?: string;
             /**
             How to combine the input values into a single output value. When
             not given, the array of input values becomes the output. This
@@ -1136,7 +1223,7 @@ declare namespace GardState {
         /**
         A facet reader can be used to fetch the value of a facet,
         through {@link GardState.facet} or as a dependency in {@link
-        GardState.Facet.compute `Facet.compute`}, but not to define
+        GardState.Facet.derive `Facet.derive`}, but not to define
         new values for the facet.
         */
         type Reader<Output> = {
@@ -1240,11 +1327,15 @@ declare namespace GardState {
     transaction.
     */
     class Compartment {
+        /**
+        The compartment's debugging name, if given.
+        */
+        readonly name: string | null;
         private constructor();
         /**
         Define a new compartment.
         */
-        static define(): Compartment;
+        static define(name?: string): Compartment;
         /**
         Create an instance of this compartment to add to your {@link
         GardState.Spec.config state configuration}.
@@ -1314,7 +1405,7 @@ declare namespace GardState {
     */
     const visualCursorMotion: Facet<boolean, boolean>;
     /**
-    @hidden FIXME expose this?
+    @hidden
     */
     const isAtom: Facet<[Plot.Type<unknown>, boolean], Map<Plot.Type<unknown>, boolean>>;
 }