@react-x11/components 0.4.0 → 0.5.0

package/dist/maps/types.d.ts

@@ -0,0 +1,244 @@
+import type { Style } from 'react-x11/style';
+import type { ReactNode, Ref } from 'react';
+import type { LngLat, LngLatBounds, MapCamera, TileId } from './proj.js';
+import type { MapSource } from './sources.js';
+import type { MapStyle } from './style.js';
+import type { MapMarker, MapOverlay } from './overlay.js';
+export type { LngLat, LngLatBounds, MapCamera };
+export type { MapSource, TileData, TileRequest } from './sources.js';
+export type { MapMarker, MapOverlay, OverlayPalette } from './overlay.js';
+export type { MapStyle, MapStyleLayer, MapFilter, FillLayer, LineLayer, CircleLayer, SymbolLayer, Zoomed, } from './style.js';
+/** Where a pointer event happened, in every space that could be wanted. */
+export interface MapPointerEvent {
+    /** Geographic. */
+    lngLat: LngLat;
+    /** Pane-local logical pixels. */
+    x: number;
+    y: number;
+    /** The marker under the pointer, when there was one. */
+    marker: MapMarker | null;
+    /** Modifier state, as the synthetic event reported it. */
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    /** `1` left, `2` middle, `3` right. */
+    button: number;
+}
+/** What one frame cost — for a performance HUD, and what
+ *  `scripts/bench/maps.ts` reads. */
+export interface MapFrameStats {
+    /** Milliseconds spent rasterizing tiles into their surfaces this frame.
+     *  Bounded by `rasterBudgetMs` except for the one run that crossed it. */
+    rasterMs: number;
+    /** …and compositing them, drawing the labels, overlays and markers. */
+    drawMs: number;
+    /** Tiles the cover asked for. */
+    tiles: number;
+    /** …of which were composited from their own finished surface. Under
+     *  `progressive` this also counts the half-drawn ones. */
+    ready: number;
+    /** …and how many were drawn from a coarser ancestor instead, scaled up.
+     *  What covers a hole while zooming *in*. */
+    fromAncestor: number;
+    /** …and how many from their finer descendants, scaled down. What covers
+     *  a hole while zooming *out*, where there is no ancestor to borrow. */
+    fromDescendant: number;
+    /** Tiles still to rasterize — non-zero means the map is still sharpening
+     *  and another frame is already scheduled. */
+    pending: number;
+    /** Labels placed, and labels drawn. */
+    labels: number;
+    /**
+     * Tiles in the cover whose load failed and are waiting on a retry.
+     *
+     * Here because a map whose tiles all fail looks exactly like a map that
+     * is still loading — an empty background and nothing else — and the
+     * difference is not something a user can see.
+     */
+    errors: number;
+    /** Bytes of rendered surfaces the cache is holding. */
+    surfaceBytes: number;
+    /**
+     * What this pass repainted, in device pixels, or `null` for a full one.
+     *
+     * The number to watch when a map looks busy: a frame that is only
+     * continuing a rasterization should claim almost nothing, because the
+     * tile being drawn is a second surface nobody is looking at. A run of
+     * full-pane damage while tiles are still landing means something is
+     * asking for repaints it does not need — which on a backend that paints
+     * many frames a second reads as flashing.
+     */
+    damage: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** What the rasterizer did, summed over the tiles drawn this frame. */
+    draw: {
+        features: number;
+        vertices: number;
+        decimated: number;
+        culled: number;
+        batches: number;
+    };
+}
+/** Options for framing a box. */
+export interface FitBoundsOptions {
+    /** Logical pixels kept clear on every side. 24 by default. */
+    padding?: number;
+    maxZoom?: number;
+}
+/** The imperative surface, through `ref`. */
+export interface MapHandle {
+    getCamera(): MapCamera;
+    setCamera(camera: Partial<MapCamera>): void;
+    panBy(dx: number, dy: number): void;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    zoomTo(zoom: number): void;
+    /** Frame a box. */
+    fitBounds(bounds: LngLatBounds, options?: FitBoundsOptions): void;
+    /** Frame every marker, or the ones named. */
+    fitMarkers(ids?: readonly string[], options?: FitBoundsOptions): void;
+    /** What the pane can see. `west > east` across the antimeridian. */
+    getBounds(): LngLatBounds;
+    /** Geography to pane-local logical pixels, and back. */
+    project(position: LngLat): {
+        x: number;
+        y: number;
+    };
+    unproject(x: number, y: number): LngLat;
+    /** The marker at a pane-local point, or null. */
+    markerAt(x: number, y: number): MapMarker | null;
+    /** Throw away every rendered tile — after a style edit an application
+     *  made in place, which the map cannot see. */
+    refresh(): void;
+    /** What the last frame cost. */
+    stats(): MapFrameStats | null;
+}
+/** What the `<mapview>` element takes. `<Map>` adds the uncontrolled
+ *  camera and the box around it. */
+export interface MapViewProps {
+    /**
+     * Where tiles come from, drawn in order — a basemap, then an overlay
+     * pyramid over it. Empty draws the style's background and nothing else,
+     * which is what a map with only markers on it wants.
+     */
+    sources?: readonly MapSource[];
+    /** How to draw them. Defaults to {@link shortbreadStyle} in the theme's
+     *  light or dark palette. */
+    mapStyle?: MapStyle;
+    /**
+     * The camera, controlled. Leave it out and the **element** owns it —
+     * which is not just a convenience: an element-owned camera means a pan is
+     * a blit and a claim, with no React render in the loop at all.
+     */
+    camera?: MapCamera;
+    /** Where an element-owned camera starts. Read once, at construction. */
+    defaultCamera?: MapCamera;
+    onCameraChange?: (camera: MapCamera) => void;
+    /** Fired when a gesture ends and the camera has settled — the moment to
+     *  fetch what is now on screen. */
+    onMoveEnd?: (camera: MapCamera) => void;
+    minZoom?: number;
+    maxZoom?: number;
+    markers?: readonly MapMarker[];
+    overlays?: readonly MapOverlay[];
+    onMapClick?: (event: MapPointerEvent) => void;
+    onMarkerClick?: (marker: MapMarker, event: MapPointerEvent) => void;
+    /**
+     * The marker under the pointer, or null when it left every marker.
+     *
+     * `event` is null for the leave that comes from the pointer leaving the
+     * map altogether: there is no position on the map to report, and
+     * inventing one would be worse than saying so.
+     */
+    onMarkerHover?: (marker: MapMarker | null, event: MapPointerEvent | null) => void;
+    /** `false` freezes the camera: no drag, no wheel, no keys. The map still
+     *  draws and still reports clicks. */
+    interactive?: boolean;
+    /**
+     * Show a tile as it is drawn rather than when it is finished.
+     *
+     * `false` by default, which is what every other map client does: a tile
+     * appears whole, and until it does the coarser one already in the cache
+     * is scaled up in its place. `true` composites a tile's surface as soon
+     * as it exists — so a dense tile arrives as water, then landuse, then
+     * road casings, then roads, across a dozen frames — which is honest about
+     * what the renderer is doing and does not look like a map.
+     *
+     * The one thing the default costs is a transition that invalidates every
+     * surface at once: a `mapStyle` change, `refresh()`, or a display-scale
+     * change leaves no finished tile *and* no finished ancestor, so the map
+     * drops to its background colour until the new tiles land. `true` shows
+     * it repainting instead.
+     */
+    progressive?: boolean;
+    /**
+     * Milliseconds a frame may spend rasterizing tiles. 8 by default, which
+     * leaves the rest of a 60 Hz frame for everything else; a tile that takes
+     * longer than the budget is finished over the frames after it. `0`
+     * suspends rasterization, which is what a gesture does on its own.
+     */
+    rasterBudgetMs?: number;
+    /**
+     * Device pixels per logical pixel for the tile surfaces, if not the
+     * display's.
+     *
+     * Lowering it to 1 on a retina panel makes rasterization about 1.6×
+     * quicker and the basemap correspondingly softer; labels, markers and
+     * overlays are unaffected, since none of them goes through a tile
+     * surface. Worth having on a slow machine, and worth knowing about before
+     * reaching for it.
+     */
+    rasterScale?: number;
+    /** Bytes of rendered tile surfaces to keep. 128 MB by default. */
+    surfaceBudget?: number;
+    /**
+     * Vertices after which the rasterizer flushes its path. 12,000 by
+     * default.
+     *
+     * A real trade on X11, where a fill becomes one coverage-mask upload and
+     * a bigger path is fewer of them over the same pixels. It used to be a
+     * per-backend trade — `CGContextStrokePath` was quadratic in the number
+     * of subpaths, so the Cocoa backend wanted the opposite value and this
+     * element probed for it — and react-x11 2.6.1 chunks that stroke inside
+     * the backend instead (react-x11#457). Set it only with a profile in
+     * hand.
+     */
+    batchVertices?: number;
+    /** What the licence requires, drawn in the corner. Taken from the
+     *  sources when they carry one; `''` removes it, which is the
+     *  application saying it has put the attribution somewhere else. */
+    attribution?: string;
+    /** Called once per painted frame with what it cost. */
+    onFrame?: (stats: MapFrameStats) => void;
+    /**
+     * Called once per failed tile load, with whatever the source threw.
+     *
+     * Nothing is drawn for a failed tile, so without this a source that is
+     * misconfigured, rate-limited or down is indistinguishable from one that
+     * is slow. The tile is retried on a backoff (0.5 s doubling to 30 s), so
+     * this fires again for each retry rather than once and forever.
+     */
+    onTileError?: (error: unknown, tile: TileId & {
+        sourceId: string;
+    }) => void;
+    style?: Style;
+    role?: string;
+    'aria-label'?: string;
+    'data-testname'?: string;
+    ref?: Ref<unknown>;
+}
+/** What `<Map>` takes. */
+export interface MapProps extends Omit<MapViewProps, 'ref'> {
+    ref?: Ref<MapHandle>;
+    /** Anything absolutely positioned over the map — a legend, a control
+     *  panel. Laid out as siblings of the drawn pane rather than inside it,
+     *  because a registered element paints its children *before* its own
+     *  drawing and anything inside would be painted over. */
+    children?: ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/maps/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/maps/types.ts"],"names":[],"mappings":"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"}

package/dist/maps/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/maps/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/maps/types.ts"],"names":[],"mappings":""}

package/dist/reorder/hx.d.ts

@@ -0,0 +1,18 @@
+import type { Key, ReactElement, ReactNode } from 'react';
+import type { ReactX11Elements, Theme } from 'react-x11';
+/** The host elements, by name. */
+export type Host = ReactX11Elements;
+interface CommonProps {
+    key?: Key;
+    /** Honoured by every node at runtime; declared only on `<window>` — the
+     *  same narrow declaration the calendar works around. */
+    theme?: Theme | Record<string, string | number>;
+    /** The query hook every component forwards (docs/README.md,
+     *  "Conventions"). react-x11 passes `data-*` through; the declarations
+     *  just do not spell it, so it is added here rather than cast away at
+     *  every call site. */
+    'data-testname'?: string;
+}
+export declare function hx<K extends keyof Host>(type: K, props?: (Omit<Host[K], 'theme'> & CommonProps) | null, ...children: ReactNode[]): ReactElement;
+export {};
+//# sourceMappingURL=hx.d.ts.map

package/dist/reorder/hx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hx.d.ts","sourceRoot":"","sources":["../../src/reorder/hx.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEzD,kCAAkC;AAClC,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAEpC,UAAU,WAAW;IACnB,GAAG,CAAC,EAAE,GAAG,CAAC;IACV;6DACyD;IACzD,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAChD;;;2BAGuB;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,EAAE,CAAC,CAAC,SAAS,MAAM,IAAI,EACrC,IAAI,EAAE,CAAC,EACP,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,WAAW,CAAC,GAAG,IAAI,EACrD,GAAG,QAAQ,EAAE,SAAS,EAAE,GACvB,YAAY,CAEd"}

package/dist/reorder/hx.js

@@ -0,0 +1,10 @@
+// `React.createElement`, typed against react-x11's host elements — a copy of
+// `src/tabs/hx.ts`, duplicated on purpose: components in this package do not
+// import each other (a lateral import welds two components into one
+// tree-shaking unit — see AGENTS.md), and thirty shared lines are cheaper
+// than that. See `src/internal/hx.ts` for the full why of the shape.
+import React from 'react';
+export function hx(type, props, ...children) {
+    return React.createElement(type, props, ...children);
+}
+//# sourceMappingURL=hx.js.map

package/dist/reorder/hx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hx.js","sourceRoot":"","sources":["../../src/reorder/hx.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,6EAA6E;AAC7E,oEAAoE;AACpE,0EAA0E;AAC1E,qEAAqE;AACrE,OAAO,KAAK,MAAM,OAAO,CAAC;AAmB1B,MAAM,UAAU,EAAE,CAChB,IAAO,EACP,KAAqD,EACrD,GAAG,QAAqB;IAExB,OAAO,KAAK,CAAC,aAAa,CAAC,IAAc,EAAE,KAAc,EAAE,GAAG,QAAQ,CAAC,CAAC;AAC1E,CAAC"}

package/dist/reorder/index.d.ts

@@ -0,0 +1,314 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { DragEndEvent, DragEvent, DragSourceProps, DropAccept, DropEvent } from 'react-x11';
+import type { Style } from 'react-x11/style';
+import type { ReorderEdge, ReorderId, ReorderOrientation } from './model.js';
+export { arrayMove, closestSlot, insertAtSlot, insertManyAtSlot, isNoopSlot, moveManyToSlot, moveToSlot, slotMark, } from './model.js';
+export type { ReorderEdge, ReorderId, ReorderOrientation, ReorderPoint, ReorderRect, ReorderSlot, } from './model.js';
+/** What `style` props here accept, matching the rest of the package. */
+type StyleInput = Style | Style[];
+/**
+ * The private payload type every item offers. The scope suffix is what
+ * `dropAccept` matches on — see the header. Exported because it is the one
+ * string only this component writes (the tree-shaking guard keys on it),
+ * and because an app's own dropzone may want to refuse or take a list item
+ * by name.
+ */
+export declare const REORDER_TYPE = "application/x-react-x11-reorder";
+/** Where a drag is being driven from. */
+export type ReorderInput = 'pointer' | 'keyboard';
+/** A move within one list. `items` is the ids in their new order — what an
+ *  app holding ids sets its state to — and `from`/`to` are what one holding
+ *  objects hands to `arrayMove`. `ids` is everything that moved, which is
+ *  `[id]` unless a multi-drag carried a selection. */
+export interface ReorderChange {
+    items: ReorderId[];
+    id: ReorderId;
+    ids: ReorderId[];
+    from: number;
+    to: number;
+}
+/** An item from another `<ReorderList>` in the group landed here. `items` is
+ *  this list's ids with `id` already in place; `source` is where it came
+ *  from — hello-pangea's `{ droppableId, index }`, by other names. `action`
+ *  is `'copy'` when the source offered a copy, and then it keeps its own. */
+export interface ReorderInsert {
+    items: ReorderId[];
+    id: ReorderId;
+    ids: ReorderId[];
+    index: number;
+    action: 'move' | 'copy';
+    source: {
+        list: string | undefined;
+        index: number;
+    };
+    event: DropEvent;
+}
+/** An item of this list was taken by something else: another list in the
+ *  group (`to` says which, and where), or — `to: null` — a plain
+ *  `dropAccept` node in the app, or another application, that accepted a
+ *  `move`. Fires only for a move; a copy leaves the item where it is. */
+export interface ReorderRemove {
+    items: ReorderId[];
+    id: ReorderId;
+    ids: ReorderId[];
+    index: number;
+    to: {
+        list: string | undefined;
+        index: number;
+    } | null;
+    event: DragEndEvent;
+}
+/** A drop *onto* an item rather than between two — `combine` on the list
+ *  that took it. The dragged item is still the source list's until the app
+ *  removes it: a merge is the app's operation, so nothing is reordered and
+ *  `onRemove` fires on the source exactly as it does for a cross-list move. */
+export interface ReorderCombine {
+    id: ReorderId;
+    ids: ReorderId[];
+    /** The item it was dropped onto, and where that item is. */
+    into: ReorderId;
+    index: number;
+    source: {
+        list: string | undefined;
+        index: number;
+    };
+    event: DropEvent;
+}
+/** A foreign payload — files, text, anything `accept` took — dropped at a
+ *  slot. The event is core's, so `files`, `text` and `getData` are on it. */
+export interface ReorderDrop {
+    index: number;
+    event: DropEvent;
+}
+/** What `canDrop` is asked, once per pointer position and again at the drop.
+ *  A list item drag names `id`/`ids`/`source`; a foreign payload leaves them
+ *  undefined and empty, and `event.types` is what it is offering. */
+export interface ReorderDropQuery {
+    id?: ReorderId;
+    ids: ReorderId[];
+    source: {
+        list: string | undefined;
+        index: number;
+    } | null;
+    /** The slot it would land at. */
+    index: number;
+    /** The item it would merge into, when the pointer is in a combine band. */
+    combine: ReorderId | null;
+    event: DragEvent;
+}
+/** The drag started — a press past the threshold, or a keyboard lift. Fires
+ *  on the list the item belongs to. */
+export interface ReorderDragStart {
+    id: ReorderId;
+    ids: ReorderId[];
+    index: number;
+    input: ReorderInput;
+}
+/** Where the drag is now. Fires on the list the item belongs to, whichever
+ *  list the pointer is over — `over` is null over anything that is not a
+ *  list in the group. `over.index` is the index the item would **land at**,
+ *  which is what `onReorder`'s `to` and `onInsert`'s `index` will say, not
+ *  the raw gap it is hovering. */
+export interface ReorderDragUpdate {
+    id: ReorderId;
+    ids: ReorderId[];
+    from: number;
+    over: {
+        list: string | undefined;
+        index: number;
+    } | null;
+    combine: ReorderId | null;
+    input: ReorderInput;
+}
+/** The gesture is over, however it ended. Fires on the list the item
+ *  belongs to, after `onReorder`/`onInsert`/`onRemove`. */
+export interface ReorderDragEnd {
+    id: ReorderId;
+    ids: ReorderId[];
+    from: number;
+    to: {
+        list: string | undefined;
+        index: number;
+    } | null;
+    combine: ReorderId | null;
+    reason: 'drop' | 'cancel';
+    input: ReorderInput;
+}
+/** What `styles.item` and `renderPreview` are handed. */
+export interface ReorderItemState {
+    id: ReorderId;
+    /** The pointer is dragging this item. */
+    dragging: boolean;
+    /** The keyboard has lifted this item. */
+    lifted: boolean;
+    disabled: boolean;
+    /** Which of this item's edges the indicator is on, while a drag is over
+     *  the list. */
+    edge: ReorderEdge | null;
+    /** A drop here would merge into this item rather than land beside it —
+     *  the list's `combine`, and the pointer in this item's middle band. */
+    combining: boolean;
+    /** While the pointer drags this item: whether whatever is under the
+     *  pointer would take it — a list in the group, a dropzone in the app,
+     *  another application. False otherwise, the keyboard's lift included. */
+    accepted: boolean;
+    /** This render is the ghost's copy of the item, not the item in the list.
+     *  What a child that renders in both asks before it draws its lighter
+     *  version. */
+    preview: boolean;
+    /** Everything travelling with this item — `[id]`, unless the list's
+     *  `selected` held it and a multi-drag picked the set up. */
+    ids: readonly ReorderId[];
+}
+export interface ReorderStyles {
+    /** The state seam: merged over the item's own `style`, so it can replace
+     *  the wash a held item wears. */
+    item?: (state: ReorderItemState) => StyleInput | null | undefined | false;
+    handle?: StyleInput;
+    /** The insertion line, and the outline a combining item wears — the state
+     *  tells them apart. */
+    indicator?: StyleInput;
+    /** The card the default preview draws the item's children in. */
+    preview?: StyleInput;
+}
+/** How big the ghost is. A function is asked once, at the drag's start. */
+export type ReorderPreviewSize = {
+    width: number;
+    height: number;
+} | ((state: ReorderItemState) => {
+    width: number;
+    height: number;
+});
+export interface ReorderListProps {
+    /** Names this list in the events other lists receive (`source.list`,
+     *  `to.list`). */
+    id?: string;
+    /** Lists sharing a group accept each other's items. Without one a list
+     *  takes only its own. */
+    group?: string;
+    /** Which way the items run. Decides the indicator's edge and the arrow
+     *  keys; the root's `flexDirection` follows it. Default `'vertical'`. */
+    orientation?: ReorderOrientation;
+    /** Nothing drags, nothing lifts, nothing lands. */
+    disabled?: boolean;
+    /** The ids a multi-drag picks up together: dragging one of them carries
+     *  all of them, in this list's own order. The app holds the selection. */
+    selected?: readonly ReorderId[];
+    /** An item moved within this list. */
+    onReorder?: (change: ReorderChange) => void;
+    /** An item arrived from another list in the group. */
+    onInsert?: (change: ReorderInsert) => void;
+    /** An item of this list was moved elsewhere. */
+    onRemove?: (change: ReorderRemove) => void;
+    /** A drop *onto* one of this list's items. Needs `combine`. */
+    onCombine?: (change: ReorderCombine) => void;
+    /** Whether the middle of an item is a merge target rather than an edge.
+     *  Without `onCombine` it is inert. Default false. */
+    combine?: boolean;
+    /** The last word on whether a drop lands here, asked per pointer position
+     *  and again at the drop. It can only *refuse* what `group`/`accept`
+     *  already matched — see the header. */
+    canDrop?: (query: ReorderDropQuery) => boolean;
+    /** Foreign payloads the list takes, in core's `dropAccept` vocabulary —
+     *  `['files']`, `'text/plain'`, a predicate. Without it every drag that is
+     *  not a list item is refused. */
+    accept?: DropAccept;
+    /** A foreign payload landed, at `index`. */
+    onDrop?: (drop: ReorderDrop) => void;
+    /** The drag started: a press past the threshold, or a keyboard lift. */
+    onDragStart?: (ev: ReorderDragStart) => void;
+    /** Where the drag is now — one per pointer position that changed the
+     *  answer, and one per keyboard step. */
+    onDragUpdate?: (ev: ReorderDragUpdate) => void;
+    /** The gesture is over, after the change events. */
+    onDragEnd?: (ev: ReorderDragEnd) => void;
+    /**
+     * The ghost that follows the pointer while an item is held.
+     *
+     * `'auto'` (the default, and what `true` means) is a `<popup>`: a window
+     * of its own, so it follows the pointer out of the list, out of the
+     * window, and over other applications, on both backends.
+     *
+     * `'inline'` draws it as a box inside the list instead — no second window
+     * per drag, which a remote display may prefer, at the cost of a ghost
+     * that stops at the window's edge. `false` leaves only the cursor and the
+     * indicator.
+     */
+    preview?: boolean | 'auto' | 'popup' | 'inline';
+    /** What the ghost shows. Default: the item's children again, on a card. */
+    renderPreview?: (state: ReorderItemState) => ReactNode;
+    /** How big the ghost is. Default: the item's own size. */
+    previewSize?: ReorderPreviewSize;
+    /** Whether the ghost flies to where the item landed instead of vanishing,
+     *  and for how long (default 180ms). Off under the desktop's reduced
+     *  motion, whatever this says. */
+    dropAnimation?: boolean | number;
+    styles?: ReorderStyles;
+    style?: StyleInput;
+    'data-testname'?: string;
+    children?: ReactNode;
+}
+export interface ReorderItemProps {
+    id: ReorderId;
+    /** Not draggable and not liftable — but still a slot others land beside. */
+    disabled?: boolean;
+    /** Offered beside the reorder payload, for other targets in the app and
+     *  for other applications — core's `dragData`, thunks and all. */
+    dragData?: DragSourceProps['dragData'];
+    /** What the drag offers. Default `['move']`; `['copy']` makes this list a
+     *  palette — the item stays, and the list that takes it gets
+     *  `onInsert({ action: 'copy' })`. */
+    dragActions?: Array<'copy' | 'move' | 'link'>;
+    /** Let a press on a control inside the item start a drag anyway. Off by
+     *  default, so a text field, a slider or a button inside a card keeps the
+     *  press — see the header. Moot when the item has a handle. */
+    dragFromInteractive?: boolean;
+    /** What a screen reader calls the item. Default: its own text. */
+    'aria-label'?: string;
+    style?: StyleInput;
+    'data-testname'?: string;
+    /** The content — or a function of the item's state, for content that
+     *  reacts to the drag. `useReorderItem()` is the same thing for a
+     *  component deeper inside. */
+    children?: ReactNode | ((state: ReorderItemState) => ReactNode);
+}
+export interface ReorderHandleProps {
+    /** Default "Drag to reorder". */
+    'aria-label'?: string;
+    style?: StyleInput;
+    'data-testname'?: string;
+    /** Default: a grip of six dots. */
+    children?: ReactNode;
+}
+/**
+ * The state of the `<ReorderItem>` a component is rendered inside — what
+ * function `children` are handed, for a component deeper in the item. Reads
+ * `preview` to tell the ghost's copy from the item in the list.
+ */
+export declare function useReorderItem(): ReorderItemState;
+/**
+ * `<ReorderList onReorder>` around `<ReorderItem id>`s.
+ *
+ *   <ReorderList onReorder={(e) => setTodos((l) => arrayMove(l, e.from, e.to))}>
+ *     {todos.map((t) => (
+ *       <ReorderItem key={t.id} id={t.id}><text>{t.title}</text></ReorderItem>
+ *     ))}
+ *   </ReorderList>
+ *
+ * The order is read from the tree the list rendered, so it is written once —
+ * there is no `items` array to keep beside the children.
+ */
+export declare function ReorderList(props: ReorderListProps): ReactElement;
+/**
+ * `<ReorderItem id>` — one item. Draggable by any part of itself, unless a
+ * `<ReorderHandle>` inside it takes that over; a tab stop, with the keyboard
+ * model on it, for the same "unless".
+ */
+export declare function ReorderItem(props: ReorderItemProps): ReactElement;
+/**
+ * `<ReorderHandle>` — the one part of an item that drags it. Rendering one
+ * inside a `<ReorderItem>` is the whole opt-in: the item stops being the
+ * press target and the tab stop, and this is both.
+ */
+export declare function ReorderHandle(props: ReorderHandleProps): ReactElement;
+//# sourceMappingURL=index.d.ts.map

package/dist/reorder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reorder/index.ts"],"names":[],"mappings":"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"}