@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

package/declarations/app/ui-kit/modifiers/d-drag-dwell.d.ts

@@ -0,0 +1,215 @@
+import type { CleanupFn } from "@atlaskit/pragmatic-drag-and-drop/types";
+import type { DragInput, DragLocation } from "discourse/lib/-internals/drag-and-drop/drop-target-kernel";
+import { type ExternalDragKind, type ExternalDragPayload } from "discourse/lib/-internals/drag-and-drop/external-vocabulary";
+import { type NormalizedDragSource } from "discourse/lib/-internals/drag-and-drop/vocabulary";
+export { default as createDragDwell, DEFAULT_DRAG_DWELL_DELAY, type DragDwell, type DragDwellOptions, } from "discourse/lib/-internals/drag-and-drop/drag-dwell";
+/** Which adapter the observed drag arrived through. */
+export type DragDwellFamily = "element" | "external";
+/** The dragged payload a dwell observes, from either adapter. */
+export type DragDwellSource = NormalizedDragSource | ExternalDragPayload;
+/**
+ * The observed drag: which adapter carried it, discriminating the payload
+ * shape. Checking `family` narrows `source`.
+ */
+type DragDwellObservation = {
+    /** The drag came from a registered element source. */
+    family: "element";
+    /** The dragged payload, normalized. */
+    source: NormalizedDragSource;
+} | {
+    /** The drag came from outside the window. */
+    family: "external";
+    /** The decorated external payload. */
+    source: ExternalDragPayload;
+};
+/**
+ * What {@link DragDwellArgs.canDwell} receives — structurally what a drop
+ * target's `canDrop` receives, so one gating function can serve both.
+ */
+export type DragDwellFeedback = DragDwellObservation & {
+    /** The pointer, with `clientX`/`clientY`. */
+    input: DragInput;
+    /** The dwell host element. */
+    element: HTMLElement;
+};
+/** What {@link DragDwellArgs.onDwell} receives. */
+export type DragDwellEvent = DragDwellObservation & {
+    /** The drag's positions: `initial`, `previous`, and `current`. */
+    location: DragLocation;
+    /** The dwell host element. */
+    element: HTMLElement;
+};
+/** Why a candidacy ended. */
+export type DragDwellEndReason = "left" | "drag-ended";
+/** What {@link DragDwellArgs.onDwellEnd} receives. */
+export type DragDwellEndEvent = DragDwellEvent & {
+    /**
+     * `"left"` when the drag stopped hovering the element or stopped
+     * qualifying; `"drag-ended"` when the drag finished anywhere — dropped,
+     * abandoned, or cancelled.
+     */
+    reason: DragDwellEndReason;
+    /** Whether `onDwell` had fired for this candidacy — the undo predicate. */
+    fired: boolean;
+    /**
+     * On `"drag-ended"`: whether the drop landed on a drop target on this
+     * element or on one of its descendants. Always `false` for `"left"`, and
+     * `false` when the host subtree registers no drop target at all.
+     */
+    droppedHere: boolean;
+};
+interface DDragDwellSignature {
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Element drag types to watch. Omit to watch every element drag.
+             * Re-read on every frame.
+             */
+            types?: string | string[];
+            /**
+             * External drag kinds to watch. Omitting it, or naming no kinds,
+             * refuses every external drag: the dwell only reacts to drags from
+             * outside the window when a consumer asks for them.
+             */
+            externalKinds?: ExternalDragKind | ExternalDragKind[];
+            /**
+             * How long a qualifying hover lasts before `onDwell` fires. `true`, the
+             * default, is the standard 500 ms; `false` fires on the first qualifying
+             * frame; a number is the wait in milliseconds. Sampled when the first
+             * candidacy arms.
+             */
+            delay?: boolean | number;
+            /**
+             * Grace before a fired dwell is undone once the drag leaves the
+             * element. `true`, the default, mirrors the entry delay, or the
+             * standard 500 ms when entry is immediate; `false` ends it in the
+             * leaving frame; a number is the grace in milliseconds. A drag
+             * returning within the grace keeps the dwell as if it never left, and
+             * a drag ending during it reports `drag-ended` instead. A candidacy
+             * that has not fired yet ends immediately either way.
+             */
+            leaveDelay?: boolean | number;
+            /**
+             * Whether a drag hovering the element may start or continue a pending
+             * candidacy. Same feedback shape as a drop target's `canDrop`, so the
+             * two MAY share one function. Only a literal `false` refuses; it runs
+             * after `types`/`externalKinds` filtering, and is not consulted again once
+             * the dwell has fired.
+             */
+            canDwell?: (feedback: DragDwellFeedback) => boolean | void;
+            /**
+             * Whether a drag whose source element is this element, or inside it,
+             * may dwell. Defaults to `true`.
+             */
+            acceptsSelf?: boolean;
+            /** The dwell fired: the drag hovered long enough. */
+            onDwell: (event: DragDwellEvent) => void;
+            /**
+             * The candidacy ended — the drag left, stopped qualifying, or
+             * finished. The place to undo what `onDwell` did.
+             */
+            onDwellEnd?: (event: DragDwellEndEvent) => void;
+        };
+        Positional: [];
+    };
+}
+/**
+ * Every named arg of {@link dDragDwell}, for a consumer driving
+ * {@link registerDragDwell} imperatively rather than through the modifier.
+ */
+export type DragDwellArgs = DDragDwellSignature["Args"]["Named"];
+/**
+ * The entry delay in milliseconds: `true` and omission are the standard
+ * delay, `false` is immediate, and a number stands as given.
+ */
+export declare function resolveDwellDelay(delay: boolean | number | undefined): number;
+/**
+ * The leave grace in milliseconds: `true` and omission mirror the resolved
+ * entry delay and fall back to the standard delay when entry is immediate,
+ * `false` is immediate, and a number stands as given.
+ */
+export declare function resolveDwellLeaveDelay(leaveDelay: boolean | number | undefined, delay: boolean | number | undefined): number;
+/**
+ * Watches drags the way a monitor does and reports dwells on one element.
+ *
+ * This uses rectangle containment, which does not account for another element
+ * occluding the host. An element drag leaving the window can also leave one
+ * stale in-rectangle input until the drag ends. Registering the external
+ * monitor mounts that adapter page-wide, as the drag-and-drop service does.
+ *
+ * The delay is sampled when the first candidacy arms. Every other argument is
+ * read lazily from monitor or timer callbacks.
+ *
+ * @param element - The dwell host.
+ * @param getArgsRef - Closure returning the latest arguments.
+ * @returns Cleanup; call it once on teardown.
+ */
+export declare function registerDragDwell(element: HTMLElement, getArgsRef: () => DragDwellArgs): CleanupFn;
+/**
+ * Fires a callback once a drag has hovered the element for a delay, without
+ * making the element a drop target. Every arg is documented on
+ * {@link DragDwellArgs}.
+ *
+ * ```hbs
+ * <div {{dDragDwell types="card" onDwell=this.open onDwellEnd=this.close}}>
+ * ```
+ */
+declare const _default: import("ember-modifier").FunctionBasedModifier<{
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Element drag types to watch. Omit to watch every element drag.
+             * Re-read on every frame.
+             */
+            types?: string | string[];
+            /**
+             * External drag kinds to watch. Omitting it, or naming no kinds,
+             * refuses every external drag: the dwell only reacts to drags from
+             * outside the window when a consumer asks for them.
+             */
+            externalKinds?: ExternalDragKind | ExternalDragKind[];
+            /**
+             * How long a qualifying hover lasts before `onDwell` fires. `true`, the
+             * default, is the standard 500 ms; `false` fires on the first qualifying
+             * frame; a number is the wait in milliseconds. Sampled when the first
+             * candidacy arms.
+             */
+            delay?: boolean | number;
+            /**
+             * Grace before a fired dwell is undone once the drag leaves the
+             * element. `true`, the default, mirrors the entry delay, or the
+             * standard 500 ms when entry is immediate; `false` ends it in the
+             * leaving frame; a number is the grace in milliseconds. A drag
+             * returning within the grace keeps the dwell as if it never left, and
+             * a drag ending during it reports `drag-ended` instead. A candidacy
+             * that has not fired yet ends immediately either way.
+             */
+            leaveDelay?: boolean | number;
+            /**
+             * Whether a drag hovering the element may start or continue a pending
+             * candidacy. Same feedback shape as a drop target's `canDrop`, so the
+             * two MAY share one function. Only a literal `false` refuses; it runs
+             * after `types`/`externalKinds` filtering, and is not consulted again once
+             * the dwell has fired.
+             */
+            canDwell?: (feedback: DragDwellFeedback) => boolean | void;
+            /**
+             * Whether a drag whose source element is this element, or inside it,
+             * may dwell. Defaults to `true`.
+             */
+            acceptsSelf?: boolean;
+            /** The dwell fired: the drag hovered long enough. */
+            onDwell: (event: DragDwellEvent) => void;
+            /**
+             * The candidacy ended — the drag left, stopped qualifying, or
+             * finished. The place to undo what `onDwell` did.
+             */
+            onDwellEnd?: (event: DragDwellEndEvent) => void;
+        };
+        Positional: [];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=d-drag-dwell.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-dwell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-dwell.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-dwell.ts"],"names":[],"mappings":"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"}

package/declarations/app/ui-kit/modifiers/d-draggable.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Binds a press-drag lifecycle using legacy mouse and touch event pairs, plus
+ * native drag events, with document-level listeners for the gesture's duration.
+ *
+ * @deprecated since 2026.8.0. Use `dPointerDrag`
+ *   (`discourse/ui-kit/modifiers/d-pointer-drag`). Rename `didStartDrag`,
+ *   `dragMove` and `didEndDrag` to `onDragStart`, `onDrag` and `onDragEnd`, and
+ *   add `onDragCancel` so an interrupted gesture still finishes.
+ *
+ *   Three differences bite beyond the renames:
+ *   - the second callback argument is gesture info, not the element;
+ *   - the body class is automatic here, but needs `bodyClass` there;
+ *   - a touch handler reading `event.touches[0]` should read the event itself.
+ */
 export default class DDraggableModifier extends Modifier<import("ember-modifier/-private/signature").DefaultSignature> {
     constructor(owner: any, args: any);
     hasStarted: boolean;
@@ -14,6 +28,7 @@ export default class DDraggableModifier extends Modifier<import("ember-modifier/
     drag(e: any): void;
     didEndDrag(e: any): void;
     cleanup(): void;
+    #private;
 }
 import Modifier from "ember-modifier";
 //# sourceMappingURL=d-draggable.d.ts.map

package/declarations/app/ui-kit/modifiers/d-draggable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"d-draggable.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-draggable.js"],"names":[],"mappings":"AAIA;IAIE,mCAGC;IAND,oBAAmB;IACnB,aAAQ;IAOR;;;;aAcC;IAZC,0BAAwC;IACxC,wBAAoC;IACpC,sBAAgC;IAYlC,uBA0BC;IAED,mBAKC;IAED,yBAYC;IAED,gBAWC;CACF;qBAzFoB,gBAAgB"}
+{"version":3,"file":"d-draggable.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-draggable.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IAKE,mCAOC;IAXD,oBAAmB;IACnB,aAAQ;IAYR;;;;aAcC;IAZC,0BAAwC;IACxC,wBAAoC;IACpC,sBAAgC;IAYlC,uBA0BC;IAED,mBAKC;IAED,yBAaC;IAED,gBAYC;;CACF;qBAhHoB,gBAAgB"}

package/declarations/app/ui-kit/modifiers/d-on-resize.d.ts

@@ -16,6 +16,9 @@ interface DOnResizeSignature {
 /**
  * Calls `callback` with the observed `ResizeObserverEntry`s whenever the element
  * resizes, throttled through the runloop. Cleans up the observer on teardown.
+ *
+ * @see The `DResizeSeparator` / `dResizeEdge` / `DResizeHandles` primitives to let a user
+ *   PERFORM a resize. The similar names are the trap; this one only watches.
  */
 export default class DOnResize extends Modifier<DOnResizeSignature> {
     #private;

package/declarations/app/ui-kit/modifiers/d-on-resize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"d-on-resize.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-on-resize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,QAAQ,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAExD,UAAU,gBAAgB;IACxB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,mBAAmB,EAAE,KAAK,IAAI,CAAC;AAElE,UAAU,kBAAkB;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,UAAU,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC;KACvE,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,QAAQ,CAAC,kBAAkB,CAAC;;gBAIrD,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAK3D,MAAM,CACJ,OAAO,EAAE,OAAO,EAChB,CAAC,EAAE,EAAE,OAAY,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC;CAmB/D"}
+{"version":3,"file":"d-on-resize.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-on-resize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,QAAQ,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAExD,UAAU,gBAAgB;IACxB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,mBAAmB,EAAE,KAAK,IAAI,CAAC;AAElE,UAAU,kBAAkB;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,UAAU,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC;KACvE,CAAC;CACH;AAED;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,QAAQ,CAAC,kBAAkB,CAAC;;gBAIrD,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAK3D,MAAM,CACJ,OAAO,EAAE,OAAO,EAChB,CAAC,EAAE,EAAE,OAAY,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC;CAmB/D"}

package/declarations/app/ui-kit/modifiers/d-pointer-drag.d.ts

@@ -0,0 +1,215 @@
+import type Owner from "@ember/owner";
+import Modifier, { type ArgsFor } from "ember-modifier";
+/**
+ * The `touch-action` tokens `d-pointer-drag.scss` has a rule for. A token
+ * without one leaves the element at `auto`, so the two must move together.
+ */
+export type TouchActionToken = "none" | "pan-x" | "pan-y" | "pinch-zoom" | "manipulation";
+/** A point in client coordinates. */
+type Point = Readonly<{
+    x: number;
+    y: number;
+}>;
+/**
+ * Where the gesture is, reported alongside every callback's event.
+ *
+ * A snapshot, not a live view. A fresh one is built per dispatch, so a consumer
+ * that stores it keeps the numbers it was given.
+ */
+export interface DPointerDragInfo {
+    /** Where the press landed. */
+    readonly origin: Point;
+    /** Where the pointer is now. */
+    readonly current: Point;
+    /** How far the pointer has travelled since the press. */
+    readonly delta: Point;
+    /**
+     * Whether `onDrag` has fired at least once for THIS gesture. It separates a
+     * drag from a click that landed on the handle.
+     *
+     * This is not the same as passing `threshold`. With no threshold a gesture can
+     * report from the press onwards, but it may still have reported nothing.
+     */
+    readonly moved: boolean;
+}
+interface DPointerDragSignature {
+    /** The element the gesture is bound to. */
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Return `false` to ABORT the gesture, for example when an anchor cannot
+             * be resolved. Any other return starts it. An exception here is rethrown
+             * after the pointer capture is released, and no gesture starts.
+             */
+            onDragStart?: (event: PointerEvent, info: DPointerDragInfo) => boolean | void;
+            /**
+             * Compute and preview the new value. Only fires during an active gesture,
+             * and only once `threshold` has been exceeded.
+             */
+            onDrag?: (event: PointerEvent, info: DPointerDragInfo) => void;
+            /**
+             * Compute and commit the new value. Runs BEFORE the pointer capture is
+             * released. Fires for any release on this element, including one that never
+             * reached `threshold` and saw no `onDrag`. Use `info.moved` to tell them apart.
+             */
+            onDragEnd?: (event: PointerEvent, info: DPointerDragInfo) => void;
+            /**
+             * Release any preview without committing. Neither this nor `onDragEnd`
+             * runs when the element is destroyed mid-gesture; see the modifier's own
+             * docs for what to do with state that outlives the handle.
+             */
+            onDragCancel?: (event: PointerEvent, info: DPointerDragInfo) => void;
+            /**
+             * A class toggled on the element for the gesture's duration. A single
+             * token: a value with whitespace in it is rejected by the DOM, which costs
+             * the drag its styling but leaves the gesture working.
+             */
+            draggingClass?: string;
+            /**
+             * A class held on `document.body` for the gesture's duration, for a cursor
+             * that has to survive the pointer leaving the handle. Whether that happens
+             * by itself is engine-dependent, so the rule cannot be left to the element.
+             * It reaches only what inherits `cursor`, so anything declaring its own
+             * still wins over it, and a gesture that must hold the cursor everywhere
+             * wants an overlay instead. Held by count, so two gestures asking for the
+             * same class both keep it until the last one ends.
+             *
+             * Reach for a class on a shared ancestor, not this, when the target is
+             * simply outside the dragged element's subtree — a sibling is still
+             * reachable from the parent the two have in common.
+             */
+            bodyClass?: string;
+            /**
+             * Pixels of travel, measured as a straight line from the press origin, that
+             * `onDrag` waits for before it starts firing. Reaching the distance is
+             * enough; it does not have to be exceeded. Suppresses the jitter of a click
+             * that was never meant to be a drag. Defaults to `0`. Read live until the
+             * distance is reached; only the latch is permanent, so raising it after
+             * movement has engaged will not re-suppress a gesture already under way.
+             */
+            threshold?: number;
+            /**
+             * Whether an accepted press also stops propagating. Defaults to `false`:
+             * document-level listeners (click-outside dismissal, card and menu closers)
+             * depend on seeing `pointerdown`, so suppression is opt-in for the handles
+             * that genuinely need to isolate themselves.
+             */
+            stopPropagation?: boolean;
+            /**
+             * Whether a gesture that ends without the pointer being released on this
+             * element — `pointercancel`, or the capture being taken away — commits via
+             * `onDragEnd` instead of discarding via `onDragCancel`. Defaults to
+             * `false`. A splitter wants `true`: an OS-interrupted resize should keep
+             * the size the user dragged to.
+             */
+            cancelCommits?: boolean;
+            /**
+             * Which browser touch gestures the element gives up, reflected as
+             * `data-pointer-drag` and mapped by
+             * `app/assets/stylesheets/common/ui-kit/d-pointer-drag.scss`. Defaults to
+             * `"none"`, which suits a small handle. Anything large enough that a user
+             * might start a scroll or a pinch-zoom on it wants `"pan-x"`, `"pan-y"`,
+             * `"pinch-zoom"` or `"manipulation"` instead.
+             *
+             * The union is closed against that stylesheet, so widen it only alongside
+             * a rule there: `touch-action` is not inherited, and a token with no rule
+             * behind it leaves the element at `auto`, where the browser claims the
+             * touch as a scroll and the gesture dies through `pointercancel`.
+             */
+            touchAction?: TouchActionToken;
+        };
+        Positional: [];
+    };
+}
+/**
+ * The gesture's named args, for a consumer driving {@link registerPointerDrag}
+ * imperatively rather than through the modifier.
+ */
+export type DPointerDragArgs = DPointerDragSignature["Args"]["Named"];
+/**
+ * Drops all pointer-ownership bookkeeping. For tests only: a consumer of
+ * {@link registerPointerDrag} that never invokes its cleanup would otherwise
+ * leave an entry behind that releases the next gesture to reuse that pointer ID.
+ */
+export declare function resetPointerDragForTesting(): void;
+/**
+ * Wires the "press-drag-transform" pointer lifecycle to an element: the gesture
+ * class where the user presses, drags, and a value changes continuously with the
+ * pointer (resize handles, sliders, splitters, knobs). Used by the
+ * default-exported modifier below, and exported so a consumer can install the
+ * gesture imperatively when a template modifier does not fit.
+ *
+ * This is not a transfer operation: there is no drop target or payload. The
+ * `onDrag*` callback names describe this gesture's lifecycle (start, move, end,
+ * cancel).
+ *
+ * Unified Pointer Events with `setPointerCapture` cover mouse, touch and pen
+ * without per-input branching. Only the primary button starts a gesture, and
+ * every subsequent event must carry the same `pointerId`, so a second finger
+ * landing on the element cannot drive or end a gesture the first one owns.
+ *
+ * The lifecycle is owned here; everything domain-specific (what origin to
+ * capture, how to compute the next value, how to preview it, what to commit)
+ * stays in the caller's handlers.
+ *
+ * @param element - The element the gesture is bound to.
+ * @param getArgsRef - Closure returning the latest args, read on every event so
+ *   arg changes take effect without re-registering.
+ * @returns Cleanup function. Releases an in-flight capture, so a gesture
+ *   interrupted by teardown does not strand the pointer. Caller invokes it once
+ *   on teardown.
+ */
+export declare function registerPointerDrag(element: HTMLElement, getArgsRef: () => DPointerDragArgs): () => void;
+/**
+ * Binds the press-drag-transform gesture to an element. Thin Ember-modifier
+ * wrapper around {@link registerPointerDrag}. Every arg is optional and
+ * documented on {@link DPointerDragArgs}.
+ *
+ * @example
+ * ```gjs
+ * <span {{dPointerDrag
+ *   onDragStart=this.onDragStart
+ *   onDrag=this.onDrag
+ *   onDragEnd=this.onDragEnd
+ *   onDragCancel=this.onDragCancel
+ *   draggingClass="--dragging"
+ * }} />
+ * ```
+ *
+ * A press never moves focus. Cancelling `pointerdown` suppresses the compatibility
+ * `mousedown` that focus rides on, and that suppression is kept: a handle usually
+ * sits beside the thing it resizes or reorders, so taking focus on press would pull
+ * the caret out of whatever the user was working in. Give the handle its own tab
+ * stop when it has a keyboard path worth reaching — that is how it stays operable,
+ * not by claiming focus from a gesture assistive technology cannot perform.
+ *
+ * That cancellation reaches further than focus: an accepted press produces no
+ * `mousedown` or `mouseup`, so a document-level listener on either never sees it.
+ * Build dismiss-on-outside-press on `pointerdown`, which still bubbles unless
+ * `stopPropagation` is set.
+ *
+ * A single element supports one registration. Two would each claim the same
+ * pointer capture and the same attribute, and tearing either down would strand
+ * the other's gesture.
+ *
+ * Nesting one registration inside another is supported, but only one of them can
+ * hold a given press: the ancestor sees it too, and whichever claims the pointer
+ * last keeps it. The other is ended immediately through `onDragCancel` (or
+ * `onDragEnd` under `cancelCommits`) with the same press as its event, so a
+ * contested press still leaves each consumer with one terminal callback for the
+ * `onDragStart` it received. Pass `stopPropagation` on the inner registration when
+ * the press should not reach the ancestor at all.
+ *
+ * The one end that reports nothing is teardown: destroying the element mid-gesture
+ * releases the capture and drops the classes but fires no terminal callback, since
+ * one would run against a consumer already being torn down. Release gesture state
+ * that outlives the handle from the consumer's own destructor instead.
+ */
+export default class DPointerDragModifier extends Modifier<DPointerDragSignature> {
+    #private;
+    constructor(owner: Owner, args: ArgsFor<DPointerDragSignature>);
+    modify(element: HTMLElement, _positional: [], named: DPointerDragArgs): void;
+}
+export {};
+//# sourceMappingURL=d-pointer-drag.d.ts.map

package/declarations/app/ui-kit/modifiers/d-pointer-drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-pointer-drag.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-pointer-drag.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,QAAQ,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGxD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,OAAO,GACP,OAAO,GACP,YAAY,GACZ,cAAc,CAAC;AAQnB,qCAAqC;AACrC,KAAK,KAAK,GAAG,QAAQ,CAAC;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,8BAA8B;IAC9B,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IAEvB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IAExB,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAEtB;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,qBAAqB;IAC7B,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE;QACJ,KAAK,EAAE;YACL;;;;eAIG;YACH,WAAW,CAAC,EAAE,CACZ,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,gBAAgB,KACnB,OAAO,GAAG,IAAI,CAAC;YAEpB;;;eAGG;YACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;YAE/D;;;;eAIG;YACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;YAElE;;;;eAIG;YACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;YAErE;;;;eAIG;YACH,aAAa,CAAC,EAAE,MAAM,CAAC;YAEvB;;;;;;;;;;;;eAYG;YACH,SAAS,CAAC,EAAE,MAAM,CAAC;YAEnB;;;;;;;eAOG;YACH,SAAS,CAAC,EAAE,MAAM,CAAC;YAEnB;;;;;eAKG;YACH,eAAe,CAAC,EAAE,OAAO,CAAC;YAE1B;;;;;;eAMG;YACH,aAAa,CAAC,EAAE,OAAO,CAAC;YAExB;;;;;;;;;;;;eAYG;YACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;SAChC,CAAC;QACF,UAAU,EAAE,EAAE,CAAC;KAChB,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;AAwBtE;;;;GAIG;AACH,wBAAgB,0BAA0B,SAEzC;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,MAAM,gBAAgB,cA4RnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,QAAQ,CAAC,qBAAqB,CAAC;;gBAInE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,qBAAqB,CAAC;IAK9D,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB;CAiBtE"}

package/declarations/app/ui-kit/modifiers/d-resize-edge.d.ts

@@ -0,0 +1,170 @@
+import type Owner from "@ember/owner";
+import Modifier, { type ArgsFor } from "ember-modifier";
+import type { Side } from "discourse/lib/geometry";
+import type { ResizeAxis } from "discourse/lib/resize-measurements";
+/**
+ * What produced a size report. A consumer that mirrors the size for assistive
+ * technology needs this: a held arrow key is one gesture spanning every repeat,
+ * so waiting for the commit would leave the announced value stale for as long as
+ * the key is down, where a pointer gesture reports through a frame and settles
+ * on release.
+ */
+export interface ResizeReportMeta {
+    source: "pointer" | "keyboard";
+}
+interface DResizeEdgeSignature {
+    /** The element acting as the edge. */
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * The current size, in pixels, or a function returning it. Read once at the
+             * start of each gesture — a press, or the first of a run of key repeats —
+             * and never again while one is in flight.
+             *
+             * A measurement may return `null` to say it has nothing yet. There is no
+             * size to resize *from* in that state, so the gesture is refused rather
+             * than started from an assumed zero.
+             */
+            value: number | null | (() => number | null);
+            /**
+             * The smallest size the edge may be dragged to, or a function returning it.
+             * Read every time a size is clamped.
+             */
+            min: number | (() => number);
+            /**
+             * The largest size the edge may be dragged to, or a function returning it.
+             * Read every time a size is clamped.
+             */
+            max: number | (() => number);
+            /**
+             * The axis the edge moves along. Defaults to `"horizontal"`.
+             *
+             * Note that this is the opposite of the `aria-orientation` the element
+             * should carry: that describes the separator itself, which lies across
+             * the axis it moves along.
+             */
+            axis?: ResizeAxis;
+            /**
+             * Which edge the resized element is docked against, in logical terms.
+             * Combined with the writing direction this decides whether moving the
+             * pointer away from that edge makes it larger or smaller. Defaults to
+             * `"start"`.
+             *
+             * Read live, unlike `value`, which is frozen for the length of a gesture.
+             * Changing this or `axis` mid-gesture measures the new orientation against
+             * an origin captured in the old one, so the result is undefined.
+             */
+            side?: Side;
+            /**
+             * A class held on `document.body` for the length of a gesture, for a cursor
+             * that has to survive the pointer leaving the edge. Whether the cursor of the
+             * element a drag began on does that by itself is engine-dependent, so it
+             * cannot be left to the edge's own rule.
+             */
+            bodyClass?: string;
+            /**
+             * Called once when a resize begins, immediately before the first size is
+             * reported. Purely a notification — the return value is ignored, and a
+             * caller whose size is a live measurement supplies it by passing a
+             * function as `value`.
+             *
+             * Fires on the first report rather than on the press, so a press that
+             * never becomes a resize opens nothing. Anything held for the length of
+             * the gesture belongs here, because it is always closed by exactly one
+             * `onResizeEnd`.
+             */
+            onResizeStart?: () => void;
+            /**
+             * Called while the size is changing: at most once per animation frame while
+             * dragging, and once per key press or repeat. Suitable for updating the
+             * rendered size.
+             */
+            onResize?: (size: number, meta: ResizeReportMeta) => void;
+            /**
+             * Called once when the gesture finishes. Suitable for work that should
+             * happen once per resize rather than once per report — persisting the
+             * size, or undoing something held for the length of the gesture.
+             *
+             * Every one of these is preceded by exactly one `onResizeStart`, and a
+             * gesture that reported no size fires neither: a press released without
+             * moving is a click rather than a resize, and opens nothing.
+             *
+             * The converse does not hold. Teardown mid-gesture fires no consumer
+             * callback at all, so a gesture that had reported and is then torn down
+             * leaves its `onResizeStart` unclosed. State held for the length of a
+             * resize therefore has to be released on the consumer's own destruction
+             * too, not on this alone.
+             */
+            onResizeEnd?: (size: number, meta: ResizeReportMeta) => void;
+        };
+        Positional: [];
+    };
+}
+/**
+ * Makes an element behave as a draggable edge that resizes something along one
+ * axis, following the WAI-ARIA window splitter pattern.
+ *
+ * The modifier owns the interaction only. It reports the size it computed and
+ * leaves storing and applying it to the caller, so that the same element can
+ * drive a width held in a component, a service, or a CSS custom property. The
+ * reported number carries no unit of its own: it is whatever `value`, `min`,
+ * and `max` are expressed in, which is a width for a side panel but an offset
+ * from a resting height for a composer.
+ *
+ * `value`, `min` and `max` may each be a function instead of a number, which is
+ * what a caller whose size or bounds are a live measurement of the DOM or the
+ * window must use — see `#read`.
+ *
+ * Both pointer and keyboard interaction are supported, which is what the
+ * splitter pattern requires: a resize that can only be performed by dragging
+ * is unusable without a pointing device. The pointer half is delegated to
+ * `registerPointerDrag`, the shared press-drag-transform engine, which covers
+ * mouse, touch and pen alike and marks the element so that a touch drag is not
+ * claimed by the browser as a scroll gesture. This modifier keeps the value
+ * semantics: clamping, the logical `side` handling, and the keyboard path.
+ *
+ * Both halves report the same shape — one `onResizeStart`, any number of
+ * `onResize`, one `onResizeEnd` — so a caller can hold state for the length of a
+ * resize without caring which input performed it. A held arrow key is therefore
+ * one gesture rather than one per repeat, and its running size is kept here
+ * instead of re-read from `value`: a caller whose size is a live measurement
+ * cannot settle it between repeats, and stepping from a box still moving toward
+ * the previous size would swallow most of each step.
+ *
+ * ```hbs
+ * <div
+ *   role="separator"
+ *   aria-orientation="vertical"
+ *   aria-valuenow={{this.width}}
+ *   aria-valuemin={{this.minWidth}}
+ *   aria-valuemax={{this.maxWidth}}
+ *   tabindex="0"
+ *   {{dResizeEdge
+ *     value=this.width
+ *     min=this.minWidth
+ *     max=this.maxWidth
+ *     side="start"
+ *     bodyClass="d-resizing-ew"
+ *     onResizeStart=this.suppressTransitions
+ *     onResize=this.previewWidth
+ *     onResizeEnd=this.commitWidth
+ *   }}
+ * ></div>
+ * ```
+ *
+ * @see The `DResizeSeparator` component, which wraps this and supplies the whole block of
+ *   separator markup above. Prefer it; reach for this modifier directly only when
+ *   the element and its semantics are already yours to own.
+ * @see The `DResizeHandles` component for a TWO-dimensional box resize. The separator role does
+ *   not apply there — a 2D resize has no single `aria-valuenow` to report.
+ * @see The `dOnResize` modifier to merely OBSERVE a size change. It is not a gesture.
+ */
+export default class DResizeEdgeModifier extends Modifier<DResizeEdgeSignature> {
+    #private;
+    constructor(owner: Owner, args: ArgsFor<DResizeEdgeSignature>);
+    modify(element: HTMLElement, _positional: [], named: DResizeEdgeSignature["Args"]["Named"]): void;
+    cleanup(): void;
+}
+export {};
+//# sourceMappingURL=d-resize-edge.d.ts.map