@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

package/declarations/app/ui-kit/d-virtual-list.d.ts

@@ -0,0 +1,490 @@
+import Component from "@glimmer/component";
+import type { ModifierLike } from "@glint/template";
+/** A single measured/positioned row as published by the engine. */
+interface VirtualItem {
+    key: number | string | bigint;
+    index: number;
+    start: number;
+    size: number;
+}
+/**
+ * The positioning modifier, applied as `{{row.place row.start row.index}}`. Its
+ * positional args carry the row's offset and absolute index.
+ *
+ * One stable definition shared by every row, so a row that survives a re-render
+ * re-runs its existing instance instead of being destroyed and reinstalled —
+ * where the destroy could run after the replacement wrote its styles and strip
+ * them off the reused element.
+ */
+type PlaceModifier = ModifierLike<{
+    Element: HTMLElement;
+    Args: {
+        Positional: [start: number, index: number];
+    };
+}>;
+/**
+ * The per-row context yielded as the block's second parameter. In `@ownedRow`
+ * mode the consumer renders the row element itself and applies `{{row.place}}`
+ * (positioning) and `{{row.measure}}` (measurement); simple consumers can ignore
+ * it and let the primitive wrap their content.
+ */
+interface RowContext<T> {
+    item: T;
+    index: number;
+    key: number | string | bigint;
+    start: number;
+    size: number;
+    /**
+     * Positions the row (absolute + `translateY`) when windowing; inert in the
+     * render-all fallback. Apply with the row's offset and index:
+     * `{{row.place row.start row.index}}`.
+     *
+     * Apply it BEFORE {@link measure}. It stamps the `data-index` that measurement
+     * identifies the row by, and modifiers run in template order.
+     */
+    place: PlaceModifier;
+    /**
+     * Registers the row for height measurement. Arg-less and stable; apply once per row,
+     * AFTER {@link place} — a row reached before its `data-index` is stamped cannot be
+     * identified, so it is skipped and keeps rendering at `@estimateSize`.
+     */
+    measure: ModifierLike<HTMLElement>;
+    /**
+     * The row's `aria-posinset`, or undefined when `@itemRole` is not a role that
+     * defines it. Meaningful only when every entry in `@items` is a real row: a
+     * list that also carries headers, dividers, or placeholders has to derive its
+     * own logical positions, because this counts physical rows.
+     */
+    posinset: number | undefined;
+    /** The matching `aria-setsize`. Carries the same homogeneity caveat as {@link posinset}. */
+    setSize: number | undefined;
+}
+/** The imperative handle registered via `@onRegisterApi`. */
+export interface DVirtualListApi {
+    /**
+     * Scroll a row into view.
+     *
+     * @param index - Absolute index in `@items`.
+     * @param opts - Placement within the viewport, and how to animate getting there.
+     */
+    scrollToIndex(index: number, opts?: {
+        align?: "start" | "center" | "end" | "auto";
+        behavior?: ScrollBehavior;
+    }): void;
+    /**
+     * Scroll to an absolute pixel offset in the list's coordinate space.
+     *
+     * @param offset - Offset in px from the start of the list.
+     * @param opts - How to animate getting there.
+     */
+    scrollToOffset(offset: number, opts?: {
+        behavior?: ScrollBehavior;
+    }): void;
+    /**
+     * Scroll to the first or last row. A no-op on an empty list.
+     *
+     * @param edge - Which end to travel to.
+     */
+    scrollToEdge(edge: "start" | "end"): void;
+    /**
+     * Let an edge callback fire again.
+     *
+     * An edge callback fires once and then latches, and re-arms on its own only when the reader
+     * retreats from the band or a boundary row changes. A consumer whose fetch FAILED has
+     * neither: the item set is byte-for-byte what it was, so nothing re-arms and the callback
+     * never fires again. On a list short enough that the range never leaves the band, that is
+     * permanent. This is the lever for that case.
+     *
+     * Arming is not firing. The callback runs on the next evaluation, and only if the range is
+     * still inside the band.
+     *
+     * @param edge - Which edge to re-arm. The other is left alone.
+     */
+    armEdge(edge: "start" | "end"): void;
+    /**
+     * Discard every cached row measurement so the next window re-measures from
+     * `@estimateSize`. Leaves the viewport measurement untouched.
+     */
+    measure(): void;
+    /**
+     * Re-reads the viewport's size and republishes the window from it.
+     *
+     * For a consumer that changes the viewport's size itself and would otherwise wait on a
+     * resize being observed, which the browser schedules and may not deliver promptly. Distinct
+     * from `measure`, which clears the item-size cache and leaves the viewport untouched.
+     */
+    remeasureViewport(): void;
+    /**
+     * Registers one row element for height measurement.
+     *
+     * Internal plumbing for the row `measure` modifier, exposed because that modifier is
+     * yielded to consumers. The element must carry the `data-index` that `place` stamps;
+     * anything else is ignored rather than measured under a key that does not exist.
+     */
+    measureElement(element: HTMLElement): void;
+    /**
+     * The visible index range, or undefined before the first measurement.
+     *
+     * A frozen snapshot, never the engine's own range object: the committed value of that
+     * object is what the engine's change memo compares against, so a consumer writing
+     * through it could silently stop the window updating. Every call builds a new
+     * object, so compare the indices rather than the identity.
+     */
+    visibleRange(): Readonly<{
+        startIndex: number;
+        endIndex: number;
+    }> | undefined;
+    /** Whether the viewport is mid-scroll. */
+    readonly isScrolling: boolean;
+}
+interface VisibleRange {
+    startIndex: number;
+    endIndex: number;
+}
+interface VirtualRange extends VisibleRange {
+    overscan: number;
+    count: number;
+}
+/** The visible range plus the total item count, passed to an edge callback. */
+interface EdgeInfo extends VisibleRange {
+    count: number;
+}
+interface DVirtualListSignature<T> {
+    Args: {
+        /**
+         * The full backing array. Only a window is rendered; it is never sliced.
+         *
+         * The sizer is one element as tall as the whole list, so browsers cap the
+         * reachable range at their maximum element height (on the order of 33 million
+         * px). Beyond `ceiling / @estimateSize` rows the tail cannot be scrolled to,
+         * and `@initialIndex` past it lands short.
+         */
+        items: readonly T[];
+        /** Estimated px size for a not-yet-measured row. A good estimate reduces jump. */
+        estimateSize: (item: T, index: number) => number;
+        /**
+         * Field name whose value is a row's STABLE key. Omit it and rows key by object
+         * identity — fine when `@items` holds the same objects across renders, but a
+         * consumer that rebuilds its item objects each render (same logical rows, fresh
+         * objects) would orphan every measured height and remount the whole window.
+         * Point `@key` at a stable id/key field to tie a row to its logical identity.
+         * The field must be present and unique per logical row (a missing/duplicate
+         * value aliases two rows to one key); nullish/primitive rows fall back to
+         * identity keying.
+         */
+        key?: string;
+        /** Extra rows rendered above/below the viewport to cut mount churn (default 5). */
+        overscan?: number;
+        /**
+         * Tag name for the inner container that carries `@role`, `...attributes`, and
+         * the rows (the semantic element — e.g. `"ul"` for a listbox). Resolved once
+         * at mount, with an omitted or empty value falling back to `"div"`.
+         *
+         * A container with a content model, such as `ul` or `ol`, requires
+         * `@ownedRow`: the wrapped path emits `div` rows, which those elements do not
+         * permit as children.
+         *
+         * A list container keeps its native markers unless it also carries a `@role`,
+         * since suppressing them costs the implicit list semantics some screen readers
+         * derive from the marker. The container's own box spacing is zeroed either
+         * way, so a consumer that wants visible markers owns both `list-style` and the
+         * indent they need.
+         */
+        as?: string;
+        /** Gives consumers a stable hook for sizing and styling the scroll viewport. */
+        viewportClass?: string;
+        /**
+         * Names a scroll region whose non-interactive role offers no other naming path.
+         * Naming it also makes it a `region`, since a role-less element cannot be named.
+         */
+        viewportLabel?: string;
+        /** Names the scroll viewport from existing descriptive content, as `@viewportLabel` does. */
+        viewportLabelledBy?: string;
+        /**
+         * Whether the scroll viewport may take sequential focus. Defaults to `true`, which leaves
+         * the decision to the browser.
+         *
+         * A browser with keyboard-focusable scrollers adopts a scroll container as a tab stop when
+         * it holds no focusable descendants, so that a list which can only be read by scrolling is
+         * still reachable from the keyboard. Pass `false` when the rows are already reachable some
+         * other way and that tab stop would be a dead end — a listbox whose cursor is driven by
+         * `aria-activedescendant`, for instance, leaves its options without a tabindex but is fully
+         * navigable with the arrow keys from its controller.
+         *
+         * Opt out only with such a route in hand: without one this removes the sole keyboard access
+         * to the list's content.
+         */
+        viewportTabbable?: boolean;
+        /**
+         * When set, the default block yields `[item, rowContext]` and the CONSUMER
+         * renders the row element, applying `{{rowContext.place}}` + `{{rowContext.measure}}`
+         * (no wrapper, native semantic rows). When omitted, the primitive wraps the
+         * yielded content in its own measured, `@itemRole`-stamped row element.
+         */
+        ownedRow?: boolean;
+        /**
+         * `"bottom"` rests at the end on mount and then follows appended rows, so a
+         * live-updating list stays on its newest content. Following is bounded by
+         * `@scrollEndThreshold`: a reader who has scrolled away from the end keeps
+         * their position and is never pulled down by arriving rows. Default `"top"`.
+         */
+        anchor?: "top" | "bottom";
+        /**
+         * Distance from the end, in px, that still counts as resting at the end.
+         * Governs whether `@anchor="bottom"` follows an append, and whether a row
+         * resize preserves the at-end position.
+         *
+         * Defaults to the engine's own 1px, which means "exactly at the end". A
+         * bottom-anchored list almost always wants this higher, so that a reader
+         * sitting a few px short of the end still counts as following.
+         */
+        scrollEndThreshold?: number;
+        /**
+         * On the FIRST render only, scroll so this absolute index is revealed (per
+         * `@initialAlign`). Applied once at mount; a later `@items` change never
+         * re-scrolls, so it cannot fight the user. Takes precedence over
+         * `@anchor="bottom"`.
+         *
+         * The scroll is applied a tick after the first render, because the sizer must
+         * take its height before the viewport can scroll past its initially-empty
+         * content. A deep index is therefore reached on the frame after the first
+         * paint rather than before it.
+         */
+        initialIndex?: number;
+        /** Alignment for `@initialIndex` within the viewport. Default `"start"`. */
+        initialAlign?: "start" | "center" | "end" | "auto";
+        /**
+         * Extends the default window with extra absolute indices to keep mounted.
+         *
+         * REACTIVITY CONTRACT: pass a NEW function whenever any closed-over input
+         * changes (normally by invoking a template helper). Function identity is what
+         * re-triggers the modifier and updates the engine options.
+         *
+         * PURITY CONTRACT: the engine invokes this during its own flush, outside any
+         * tracking frame, and memoizes by extractor identity plus range. Tracked state
+         * read inside the callback is silently non-reactive; it must be pure over its
+         * arguments and a closed-over snapshot. A callback that throws degrades to the
+         * unextended window and is not consulted again until its identity or the range
+         * changes.
+         *
+         * This is also the mechanism for keeping a row mounted that must not be
+         * destroyed while scrolled out of the window. A consumer managing focus or a
+         * roving tabindex has to pin the active index, or scrolling past it unmounts
+         * the focused element and focus falls back to the document.
+         */
+        pinnedIndices?: (indices: readonly number[], range: VirtualRange) => readonly number[];
+        /**
+         * Role for the inner container (the semantic element), e.g. `"listbox"` or
+         * `"feed"`. Omitted by default: a role is a promise about keyboard behaviour
+         * the primitive does not implement on the consumer's behalf, so the consumer
+         * opts in.
+         *
+         * With a non-interactive role, nothing inside the list is focusable. Use
+         * `@viewportClass` as the hook for making the viewport focusable, and name
+         * it with `@viewportLabel` or `@viewportLabelledBy`, so the region can be
+         * scrolled without a pointer.
+         */
+        role?: string;
+        /**
+         * The role each row carries, e.g. `"listitem"` or `"option"`.
+         *
+         * Without `@ownedRow` it is stamped on the row the primitive renders. With
+         * `@ownedRow` the consumer stamps the role itself and this only declares what
+         * that role will be, which is what lets `row.posinset` and `row.setSize` be
+         * computed — they are defined for a handful of roles and are omitted for the
+         * rest, so the primitive has to be told.
+         *
+         * The wrapped row exposes no `id` and no attribute pass-through, so a role
+         * needing `aria-selected`, `aria-checked`, or an id to be pointed at by
+         * `aria-activedescendant` — `option`, `radio`, `tab`, `treeitem` — cannot be
+         * fully expressed there and needs `@ownedRow`.
+         */
+        itemRole?: string;
+        /**
+         * Overrides `aria-setsize`, for when `@items` is a loaded prefix of a
+         * larger known set.
+         *
+         * Omit it when the total is unknown: ARIA's `-1` sentinel is handled
+         * inconsistently by screen readers, so negative values are refused and the
+         * loaded count is published instead.
+         */
+        setSize?: number;
+        /** Receives the imperative handle once mounted. */
+        onRegisterApi?: (api: DVirtualListApi) => void;
+        /** Fires when the visible index range changes. */
+        onVisibleRangeChange?: (range: VisibleRange) => void;
+        /**
+         * Fires once when the window enters the START band (within `@edgeThreshold`
+         * rows of the first row), re-arming after it retreats. Mount at the top is
+         * suppressed. A start-edge consumer loads rows ABOVE the anchor.
+         */
+        onReachStart?: (info: EdgeInfo) => void;
+        /**
+         * Fires once when the window enters the END band (within `@edgeThreshold`
+         * rows of the last row), re-arming after retreat. Fires on mount when the
+         * first page already reaches the end. An end-edge consumer loads more rows.
+         */
+        onReachEnd?: (info: EdgeInfo) => void;
+        /** Rows from an edge at which its reach callback arms (default 8). */
+        edgeThreshold?: number;
+    };
+    Blocks: {
+        /** Renders each item in the active window. */
+        default: [
+            /** The backing-array item. */
+            item: T,
+            /** Its measured position and row modifiers. */
+            row: RowContext<T>
+        ];
+        /** Renders when the backing array is empty. */
+        empty: [];
+    };
+    Element: HTMLElement;
+}
+/**
+ * Renders only a window of a large list while keeping the DOM bounded. The
+ * windowing engine remains behind the ui-kit library boundary.
+ *
+ * Structure: an outer role-less `.d-virtual-list` scroll VIEWPORT (the element the
+ * `dVirtualizer` modifier drives) wraps an inner `@as` CONTAINER — the semantic
+ * element that carries `@role`/`...attributes` and is the sizer (`height` = the
+ * full total) — whose rows are direct children, each absolutely positioned to its
+ * virtual offset. The component owns the tracked window (`_virtualItems`); the
+ * modifier owns the engine and pushes state in through `onState`.
+ *
+ * The consumer must give the outer viewport a nonzero height. Without one,
+ * windowing has no visible area and renders no rows.
+ *
+ * Simple consumers yield content and let the primitive wrap it in a measured,
+ * `@itemRole`-stamped row. A consumer that needs native row elements passes
+ * `@ownedRow` and renders the element itself, applying both
+ * `{{row.place row.start row.index}}` (positioning; also stamps `data-index`) and
+ * `{{row.measure}}` (height measurement). Neither requires the consumer to set
+ * `data-index`.
+ *
+ * @example
+ * ```gjs
+ * <DVirtualList @items={{this.rows}} @estimateSize={{this.estimate}} as |row|>
+ *   <MyRow @row={{row}} />
+ * </DVirtualList>
+ *
+ * <DVirtualList @items={{this.rows}} @estimateSize={{this.estimate}}
+ *   @as="ul" @role="listbox" @key="id" @ownedRow={{true}} as |item row|>
+ *   <li role="option" {{row.place row.start row.index}} {{row.measure}}>
+ *     {{item.label}}
+ *   </li>
+ * </DVirtualList>
+ * ```
+ */
+export default class DVirtualList<T> extends Component<DVirtualListSignature<T>> {
+    #private;
+    container: import("@glint/template").ComponentLike<{
+        Element: HTMLElement;
+        Blocks: {
+            default: [];
+        };
+    }>;
+    emptyContainer: import("@glint/template").ComponentLike<{
+        Element: HTMLDivElement | HTMLLIElement;
+        Blocks: {
+            default: [];
+        };
+    }>;
+    /**
+     * Makes the inner container a containing block for the absolutely positioned
+     * rows. Cleared in the render-all fallback so rows flow normally.
+     *
+     * Deliberately does NOT set the height. The modifier owns that, because it has
+     * to raise it before the engine scrolls and this runs afterwards in the same
+     * commit — Glimmer installs a parent's modifier update before a child's, so a
+     * height written from tracked state here would land second and overwrite the
+     * modifier's with the PREVIOUS flush's total. One writer avoids the collision
+     * entirely.
+     *
+     * This lands as an individual inline property rather than a `style` attribute,
+     * so a consumer's own `style` survives. Note the converse is not guaranteed: a
+     * consumer passing a DYNAMIC `style` through `...attributes` replaces the whole
+     * attribute when it updates, which drops it until the next resize.
+     */
+    sizeContainer: import("ember-modifier").FunctionBasedModifier<{
+        Args: {
+            Positional: unknown[];
+            Named: import("ember-modifier/-private/signature").EmptyObject;
+        };
+        Element: HTMLElement;
+    }>;
+    /**
+     * Registers a row for height measurement. Runs on insert and re-runs only when
+     * the api handle arrives — NOT per-render, so it does not re-measure on every
+     * window move, which would fight the engine's prepend-anchor settlement.
+     *
+     * `measureElement` identifies the row by its `data-index`, which
+     * {@link placeRow} stamps, so apply place before measure.
+     */
+    measureRow: import("ember-modifier").FunctionBasedModifier<{
+        Args: {
+            Positional: unknown[];
+            Named: import("ember-modifier/-private/signature").EmptyObject;
+        };
+        Element: HTMLElement;
+    }>;
+    /**
+     * Positions one row: stamps `data-index` (the engine reads it to identify the
+     * row) and, while windowing, positions the row absolutely at its virtual
+     * offset. Positioning is inert in the render-all fallback, so rows stay in
+     * normal flow rather than stacking at `translateY(0)`.
+     *
+     * One stable modifier DEFINITION shared by every row, applied as
+     * `{{row.place row.start row.index}}`. A row that persists across a re-render
+     * re-runs its existing instance with new args, where a definition created per
+     * row would instead be destroyed and reinstalled — and the destroy can run
+     * AFTER the replacement wrote its styles, stripping them off the reused element.
+     */
+    placeRow: import("ember-modifier").FunctionBasedModifier<{
+        Args: {
+            Positional: [start: number, index: number];
+            Named: import("ember-modifier/-private/signature").EmptyObject;
+        };
+        Element: HTMLElement;
+    }>;
+    _api: DVirtualListApi | null;
+    _virtualItems: readonly VirtualItem[];
+    /**
+     * Whether rows are windowed. Reads a module-level flag rather than tracked
+     * state, so it is fixed for the lifetime of a mounted list — flipping it
+     * afterwards does not re-render one that already exists.
+     */
+    get virtualizationActive(): boolean;
+    get rows(): Array<RowContext<T>>;
+    /** Whether `@itemRole` is one of the roles that defines position attributes. */
+    get positionAwareItems(): boolean;
+    /**
+     * `"region"` once the viewport carries a name, and otherwise absent.
+     *
+     * A `div` maps to the `generic` role, which ARIA forbids from carrying a name, so the
+     * naming arguments are inert without a role. An unnamed viewport is left alone: an
+     * unnamed region is skipped anyway, and a landmark per list would clutter the document.
+     */
+    get viewportRole(): string;
+    /**
+     * `-1` once a consumer has opted the viewport out of the tab order, and otherwise absent so
+     * the browser keeps its own judgement. Written as an explicit attribute rather than left off,
+     * because a scroller a browser has adopted reports `tabIndex === -1` either way — the
+     * attribute is what actually suppresses the adoption.
+     */
+    get viewportTabIndex(): string;
+    /**
+     * The published total: `@setSize` when given, floored at the loaded count
+     * so no `aria-posinset` can exceed it. The ARIA `-1` sentinel has no
+     * consistent screen reader implementation, so it is refused.
+     */
+    get setSize(): number;
+    onState(state: {
+        virtualItems: readonly VirtualItem[];
+        totalSize: number;
+        range: VisibleRange | null;
+    }): void;
+    onRegisterApi(api: DVirtualListApi): void;
+}
+export {};
+//# sourceMappingURL=d-virtual-list.d.ts.map

package/declarations/app/ui-kit/d-virtual-list.d.ts.map

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

package/declarations/app/ui-kit/helpers/d-category-link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"d-category-link.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/helpers/d-category-link.js"],"names":[],"mappings":"AAcA,2DAEC;AAID,0DAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,uDAVI;IAAuB,GAAG;IACH,kBAAkB;IAClB,IAAI;IACJ,UAAU;IACV,YAAY;IACZ,SAAS;IACT,SAAS;IACT,KAAK;IACL,IAAI;CAC9B,OA2CA;AAED,qGAuCC;AAED,6FAEC;AASD,8EAwGC"}
+{"version":3,"file":"d-category-link.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/helpers/d-category-link.js"],"names":[],"mappings":"AAcA,2DAEC;AAID,0DAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,uDAVI;IAAuB,GAAG;IACH,kBAAkB;IAClB,IAAI;IACJ,UAAU;IACV,YAAY;IACZ,SAAS;IACT,SAAS;IACT,KAAK;IACL,IAAI;CAC9B,OA2CA;AAED,qGAuCC;AAED,6FAEC;AASD,8EAuGC"}

package/declarations/app/ui-kit/helpers/d-element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"d-element.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/helpers/d-element.gts"],"names":[],"mappings":"AA0IA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAmFrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,CAAC,GACT,aAAa,CAAC;IACf,OAAO,EAAE,CAAC,SAAS,MAAM,qBAAqB,GAC1C,qBAAqB,CAAC,CAAC,CAAC,GACxB,WAAW,CAAC;IAChB,MAAM,EAAE;QAAE,OAAO,EAAE,EAAE,CAAA;KAAE,CAAC;CACzB,CAAC,CAAC"}
+{"version":3,"file":"d-element.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/helpers/d-element.gts"],"names":[],"mappings":"AA0KA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAoHrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,CAAC,GACT,aAAa,CAAC;IACf,OAAO,EAAE,CAAC,SAAS,MAAM,qBAAqB,GAC1C,qBAAqB,CAAC,CAAC,CAAC,GACxB,WAAW,CAAC;IAChB,MAAM,EAAE;QAAE,OAAO,EAAE,EAAE,CAAA;KAAE,CAAC;CACzB,CAAC,CAAC"}

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-auto-scroll.d.ts

@@ -0,0 +1,108 @@
+import { type ExternalDragKind } from "discourse/lib/-internals/drag-and-drop/external-vocabulary";
+import type { Axis } from "discourse/lib/geometry";
+/** Which direction the container is allowed to scroll while a drag is in flight. */
+export type AutoScrollAxis = Axis | "all";
+/** What gets scrolled: the element the modifier sits on, or the window. */
+export type AutoScrollTarget = "element" | "window";
+interface DDragAndDropAutoScrollSignature {
+    /** The scroll container, or a sentinel when `target` is `"window"`. */
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Only drags whose `type` matches engage the auto-scroll; an adopted drag
+             * answers to the adoption's declared type. Omit to engage on any element
+             * drag.
+             */
+            types?: string | string[];
+            /**
+             * Also auto-scroll for drags from outside the window, engaging on these
+             * external kinds. Omit it and an external drag scrolls nothing.
+             */
+            externalKinds?: ExternalDragKind | ExternalDragKind[];
+            /** Defaults to `"vertical"`. */
+            axis?: AutoScrollAxis;
+            /**
+             * `"element"` (default) scrolls the host element; `"window"` scrolls the
+             * window and ignores the element.
+             */
+            target?: AutoScrollTarget;
+        };
+        Positional: [];
+    };
+}
+/**
+ * The auto-scroll's named args, for a consumer driving
+ * {@link registerDragAndDropAutoScroll} imperatively rather than through the
+ * modifier.
+ */
+export type DragAndDropAutoScrollArgs = DDragAndDropAutoScrollSignature["Args"]["Named"] & {
+    /** The scroll container. Required when `target` is `"element"`. */
+    element?: HTMLElement;
+};
+/**
+ * Imperative auto-scroll registration; the `dDragAndDropAutoScroll` modifier
+ * below wraps it.
+ *
+ * @param getArgsRef - Closure returning the latest args. `types`, `axis` and
+ *   `externalKinds` are re-read on every scroll attempt; `target`, `element` and
+ *   whether `externalKinds` is set are read once here and need a fresh registration.
+ * @returns Cleanup; call it once on teardown.
+ */
+export declare function registerDragAndDropAutoScroll(getArgsRef: () => DragAndDropAutoScrollArgs): () => void;
+/**
+ * Enables auto-scroll while a compatible drag is in flight. Every arg is
+ * documented on {@link DragAndDropAutoScrollArgs}.
+ *
+ * On a scroll container:
+ *
+ * ```hbs
+ * <div class="scroll-container"
+ *   {{dDragAndDropAutoScroll types=(array "card") axis="vertical"}}
+ * >
+ * ```
+ *
+ * On a sentinel with `target="window"` to scroll the window instead:
+ *
+ * ```hbs
+ * <span class="visually-hidden"
+ *   {{dDragAndDropAutoScroll target="window" types=this.acceptedTypes}}
+ * ></span>
+ * ```
+ *
+ * With `externalKinds`, for payloads dragged in from outside the window too:
+ *
+ * ```hbs
+ * <div class="scroll-container"
+ *   {{dDragAndDropAutoScroll types=(array "card") externalKinds="urls"}}
+ * >
+ * ```
+ */
+declare const _default: import("ember-modifier").FunctionBasedModifier<{
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Only drags whose `type` matches engage the auto-scroll; an adopted drag
+             * answers to the adoption's declared type. Omit to engage on any element
+             * drag.
+             */
+            types?: string | string[];
+            /**
+             * Also auto-scroll for drags from outside the window, engaging on these
+             * external kinds. Omit it and an external drag scrolls nothing.
+             */
+            externalKinds?: ExternalDragKind | ExternalDragKind[];
+            /** Defaults to `"vertical"`. */
+            axis?: AutoScrollAxis;
+            /**
+             * `"element"` (default) scrolls the host element; `"window"` scrolls the
+             * window and ignores the element.
+             */
+            target?: AutoScrollTarget;
+        };
+        Positional: [];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=d-drag-and-drop-auto-scroll.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-auto-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-and-drop-auto-scroll.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-and-drop-auto-scroll.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,4DAA4D,CAAC;AAEpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAGnD,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,KAAK,CAAC;AAE1C,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEpD,UAAU,+BAA+B;IACvC,uEAAuE;IACvE,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE;QACJ,KAAK,EAAE;YACL;;;;eAIG;YACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;YAE1B;;;eAGG;YACH,aAAa,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAAC;YAEtD,gCAAgC;YAChC,IAAI,CAAC,EAAE,cAAc,CAAC;YAEtB;;;eAGG;YACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;SAC3B,CAAC;QACF,UAAU,EAAE,EAAE,CAAC;KAChB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GACnC,+BAA+B,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG;IACjD,mEAAmE;IACnE,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB,CAAC;AAEJ;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,yBAAyB,cAyC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;;;YArHG;;;;eAIG;oBACK,MAAM,GAAG,MAAM,EAAE;YAEzB;;;eAGG;4BACa,gBAAgB,GAAG,gBAAgB,EAAE;YAErD,gCAAgC;mBACzB,cAAc;YAErB;;;eAGG;qBACM,gBAAgB;;;;;AAkG/B,wBAWE"}