@fusion.dev/helix-headless 0.49.0 → 0.49.1

package/custom-elements.json

@@ -81056,6 +81056,16 @@
               "default": "undefined",
               "description": "Where the divider was before the gesture that may be about to shut it.\n\nA drag writes a position on every pointer move, so by the time it reaches\nthe edge the number it started from is gone. Taken once, on the press, and\nwritten back if the gesture ends shut, so the pane opens to where it was\nrather than to the edge it was dragged against."
             },
+            {
+              "kind": "field",
+              "name": "began",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "Where the divider was when the gesture now under way began.\n\nTaken on the press, read once by `settle` and cleared there. `undefined`\nbetween gestures and for every discrete path, where nothing has been\napplied yet and so the position it has *is* the position it began at.\n\nBeside `opened` rather than folded into it: that one is `undefined` for a\npane that starts shut, which is a different question and a real answer."
+            },
             {
               "kind": "field",
               "name": "reached",
@@ -81294,7 +81304,7 @@
                   }
                 }
               ],
-              "description": "Says the arrangement has settled, so a consumer can keep it.\n\nThrough the audited path, so a consumer who owns `position` is told what was\nasked for and decides, and one who does not has already had it applied.\n\n**The second announcement is conditional on the first, because it is derived\nfrom it.** `shutAt` reads the position the gesture ended on, so a refused\n`helix-before-resize` leaves a collapse computed from a number that was\nrefused. Announced anyway, the refusal produced the outcome it was refusing:\nmeasured on a divider at 40 with a listener calling `preventDefault`, Home\nleft `position` reporting 0 and `collapsed` reporting `start`, because the\ncollapse applied and `position` reads the sliver once a pane is shut. The\nreturn of the first request is what says so, and it was being dropped: a\ncancelable event dispatched as a bare statement with nothing reading the\nanswer, which is the shape the navigation cohort named on `Outline` and left.\n\nRefusing the collapse alone still leaves the resize, which is the other way\nround and is coherent: the divider goes where the drag put it and the pane\nis not declared shut. What a consumer cannot have is a pane that collapses\nout from under a position they said no to."
+              "description": "Says the arrangement has settled, so a consumer can keep it.\n\nThrough the audited path, so a consumer who owns `position` is told what was\nasked for and decides, and one who does not has already had it applied.\n\n**The second announcement is conditional on the first, because it is derived\nfrom it.** `shutAt` reads the position the gesture ended on, so a refused\n`helix-before-resize` leaves a collapse computed from a number that was\nrefused. Announced anyway, the refusal produced the outcome it was refusing:\nmeasured on a divider at 40 with a listener calling `preventDefault`, Home\nleft `position` reporting 0 and `collapsed` reporting `start`, because the\ncollapse applied and `position` reads the sliver once a pane is shut. The\nreturn of the first request is what says so, and it was being dropped: a\ncancelable event dispatched as a bare statement with nothing reading the\nanswer, which is the shape the navigation cohort named on `Outline` and left.\n\nRefusing the collapse alone still leaves the resize, which is the other way\nround and is coherent: the divider goes where the drag put it and the pane\nis not declared shut. What a consumer cannot have is a pane that collapses\nout from under a position they said no to.\n\n**A gesture that moved nothing announces nothing, and this is the one place\nthat can say so.** A change carrying the position the divider already had\nrewrites a consumer's stored value from a gesture that moved nothing:\nharmless where the value round-trips exactly, and not where it does not,\nwhich is any consumer storing pixels and dividing by a box. The separator's\n`pointerup` held that as an early return of its own and was the only door\nwith one. There are five: the separator's pointer and arrows, the corner's\npointer and arrows, and a double click through `reset`, and `moveTo` is a\nsixth a consumer can open. Measured in Chromium 17 Sep 2026 on the built\nbundle, every door but the guarded one announced a move of zero: a corner\npress with nothing between announced on both splitters, `Home` on a divider\nalready at its minimum announced, and a double click on one already at its\ndefault announced.\n\n**Measured against where the gesture began, and not against `position`.**\n`move` applies as it goes, so by the time a drag settles the position is\nalready the number about to be announced, and comparing those two would\nsilence every drag there is. `began` is the press; a discrete path takes\nnone and compares against the position, which for it is the same thing.\n\n**Per divider rather than per gesture, which is the corner's question.** The\ncorner drives two at once, so \"moved nothing\" cannot mean \"neither moved\":\na drag along one axis moves one of them, and the other would be announcing\na number nobody asked to change. Each settles on its own and guards on its\nown, so the one that moved still announces while the one that did not stays\nquiet. That is also why the guard cannot live in `handleCornerUp`, which\nonly ever sees the pair.\n\n**The collapse counts as movement, because a refusal can leave the two\ndisagreeing.** A consumer who refuses `helix-before-collapse` has a pane at\nthe edge that is not declared shut, and a guard reading the position alone\nwould then never offer the collapse again: `Home` is already at the\nminimum, so every later press is a move of zero."
             },
             {
               "kind": "field",
@@ -81806,7 +81816,7 @@
               "type": {
                 "text": "HelixBeforeResizeEvent"
               },
-              "description": "Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.",
+              "description": "Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.",
               "name": "helix-before-resize",
               "reactProp": "onhelix-before-resize"
             }

package/dist/splitter/root/splitter-root.d.ts

@@ -42,7 +42,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @slot start - The pane before the divider.
  *
  * @event {HelixBeforeCollapseEvent} helix-before-collapse - Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
- * @event {HelixBeforeResizeEvent} helix-before-resize - Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+ * @event {HelixBeforeResizeEvent} helix-before-resize - Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
  *
  * @csspart corner - The handle where two dividers cross, added on the client.
  * @csspart end - The box holding the second.
@@ -183,6 +183,17 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * rather than to the edge it was dragged against.
      */
     private opened;
+    /**
+     * Where the divider was when the gesture now under way began.
+     *
+     * Taken on the press, read once by `settle` and cleared there. `undefined`
+     * between gestures and for every discrete path, where nothing has been
+     * applied yet and so the position it has *is* the position it began at.
+     *
+     * Beside `opened` rather than folded into it: that one is `undefined` for a
+     * pane that starts shut, which is a different question and a real answer.
+     */
+    private began;
     /**
      * Where the gesture has moved to, whether or not it was applied. See `move`.
      *
@@ -335,6 +346,40 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * round and is coherent: the divider goes where the drag put it and the pane
      * is not declared shut. What a consumer cannot have is a pane that collapses
      * out from under a position they said no to.
+     *
+     * **A gesture that moved nothing announces nothing, and this is the one place
+     * that can say so.** A change carrying the position the divider already had
+     * rewrites a consumer's stored value from a gesture that moved nothing:
+     * harmless where the value round-trips exactly, and not where it does not,
+     * which is any consumer storing pixels and dividing by a box. The separator's
+     * `pointerup` held that as an early return of its own and was the only door
+     * with one. There are five: the separator's pointer and arrows, the corner's
+     * pointer and arrows, and a double click through `reset`, and `moveTo` is a
+     * sixth a consumer can open. Measured in Chromium 17 Sep 2026 on the built
+     * bundle, every door but the guarded one announced a move of zero: a corner
+     * press with nothing between announced on both splitters, `Home` on a divider
+     * already at its minimum announced, and a double click on one already at its
+     * default announced.
+     *
+     * **Measured against where the gesture began, and not against `position`.**
+     * `move` applies as it goes, so by the time a drag settles the position is
+     * already the number about to be announced, and comparing those two would
+     * silence every drag there is. `began` is the press; a discrete path takes
+     * none and compares against the position, which for it is the same thing.
+     *
+     * **Per divider rather than per gesture, which is the corner's question.** The
+     * corner drives two at once, so "moved nothing" cannot mean "neither moved":
+     * a drag along one axis moves one of them, and the other would be announcing
+     * a number nobody asked to change. Each settles on its own and guards on its
+     * own, so the one that moved still announces while the one that did not stays
+     * quiet. That is also why the guard cannot live in `handleCornerUp`, which
+     * only ever sees the pair.
+     *
+     * **The collapse counts as movement, because a refusal can leave the two
+     * disagreeing.** A consumer who refuses `helix-before-collapse` has a pane at
+     * the edge that is not declared shut, and a guard reading the position alone
+     * would then never offer the collapse again: `Home` is already at the
+     * minimum, so every later press is a move of zero.
      */
     private settle;
     private readonly handlePointerDown;

package/dist/splitter/root/splitter-root.js

@@ -22,6 +22,7 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
         this.positionState = undefined;
         this.collapsedState = undefined;
         this.opened = undefined;
+        this.began = undefined;
         this.reached = undefined;
         this.dragging = false;
         this.crossings = [];
@@ -38,6 +39,7 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
                 : { length: box.width, start: box.left };
             capturePointer(separator, event.pointerId);
             this.opened = this.collapsed ? undefined : this.position;
+            this.began = this.position;
             this.reached = undefined;
             this.dragging = true;
             event.preventDefault();
@@ -62,10 +64,7 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
             }
             this.origin = null;
             this.dragging = false;
-            if (this.reached === undefined) {
-                return;
-            }
-            this.settle(this.reached);
+            this.settle(this.reached ?? this.position);
         };
         this.handleKeydown = (event) => {
             const toward = this.travel(event.key);
@@ -117,6 +116,8 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
             capturePointer(handle, event.pointerId);
             this.opened = this.collapsed ? undefined : this.position;
             crossing.by.opened = crossing.by.collapsed ? undefined : crossing.by.position;
+            this.began = this.position;
+            crossing.by.began = crossing.by.position;
             this.reached = undefined;
             crossing.by.reached = undefined;
             this.dragging = true;
@@ -299,6 +300,11 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
     settle(next) {
         const wanted = this.clamp(next);
         const shut = this.shutAt(wanted);
+        const began = this.began ?? this.position;
+        this.began = undefined;
+        if (wanted === began && shut === this.collapsed) {
+            return;
+        }
         const moved = requestChange({
             apply: (value) => {
                 const previous = this.position;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-headless",
   "description": "Headless component tier. Structure, accessibility, state, and form participation. No styling.",
-  "version": "0.49.0",
+  "version": "0.49.1",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -46,14 +46,14 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.49.0",
-    "@fusion.dev/helix-icons": "0.49.0",
+    "@fusion.dev/helix-core": "0.49.1",
+    "@fusion.dev/helix-icons": "0.49.1",
     "uqr": "^0.1.3"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.49.0",
-    "@fusion.dev/helix-testing": "0.49.0",
+    "@fusion.dev/helix-cem": "0.49.1",
+    "@fusion.dev/helix-testing": "0.49.1",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",

package/types/jsx.d.ts

@@ -13338,7 +13338,7 @@ has an honest answer. */
   "onhelix-before-collapse"?: ((
     e: HelixHeadlessSplitterHelixBeforeCollapseElementEvent,
   ) => void) | undefined;
-  /** Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "onhelix-before-resize"?: ((
     e: HelixHeadlessSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -13442,7 +13442,7 @@ has an honest answer. */
   "on:helix-before-collapse"?: ((
     e: HelixHeadlessSplitterHelixBeforeCollapseElementEvent,
   ) => void) | undefined;
-  /** Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "on:helix-before-resize"?: ((
     e: HelixHeadlessSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -31146,7 +31146,7 @@ export type CustomElements = {
    * Events that will be emitted by the component.
    *
    * - `helix-before-collapse`: Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
-   * - `helix-before-resize`: Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
    *
    * ## Slots
    *
@@ -49194,7 +49194,7 @@ export type CustomElementsSolidJs = {
    * Events that will be emitted by the component.
    *
    * - `helix-before-collapse`: Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
-   * - `helix-before-resize`: Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
    *
    * ## Slots
    *

package/types/vue.d.ts

@@ -6879,7 +6879,7 @@ has an honest answer. */
 export type HelixHeadlessSplitterVueEvents = {
   /** Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
   "helix-before-collapse": HelixHeadlessSplitterHelixBeforeCollapseElementEvent;
-  /** Fired before the divider settles. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "helix-before-resize": HelixHeadlessSplitterHelixBeforeResizeElementEvent;
 };