@helpdice/draggable 0.0.0-stage → 0.0.1

package/dist/types/animation.d.ts

@@ -0,0 +1,31 @@
+import type { Position } from 'css-box-model';
+export declare const curves: {
+    outOfTheWay: string;
+    drop: string;
+};
+export declare const combine: {
+    opacity: {
+        drop: number;
+        combining: number;
+    };
+    scale: {
+        drop: number;
+    };
+};
+export declare const timings: {
+    outOfTheWay: number;
+    minDropTime: number;
+    maxDropTime: number;
+};
+export declare const placeholderTransitionDelayTime: number;
+export declare const transitions: {
+    fluid: string;
+    snap: string;
+    drop: (duration: number) => string;
+    outOfTheWay: string;
+    placeholder: string;
+};
+export declare const transforms: {
+    moveTo: (offset: Position) => string | null;
+    drop: (offset: Position, isCombining: boolean) => string | null;
+};

package/dist/types/debug/middleware/action-timing-average.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from '../../state/store-types';
+declare const _default: (groupSize: number) => () => (next: (arg: Action) => unknown) => (action: Action) => any;
+export default _default;

package/dist/types/debug/middleware/action-timing.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from '../../state/store-types';
+declare const _default: () => (next: (arg: Action) => unknown) => (action: Action) => any;
+export default _default;

package/dist/types/debug/middleware/log.d.ts

@@ -0,0 +1,4 @@
+import type { Action, Store } from '../../state/store-types';
+type Mode = 'verbose' | 'light';
+declare const _default: (mode?: Mode) => (store: Store) => (next: (arg: Action) => unknown) => (action: Action) => any;
+export default _default;

package/dist/types/debug/middleware/user-timing.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from '../../state/store-types';
+declare const _default: () => (next: (arg: Action) => unknown) => (action: Action) => any;
+export default _default;

package/dist/types/debug/timings.d.ts

@@ -0,0 +1,3 @@
+export declare const forceEnable: () => void;
+export declare const start: (key: string) => void;
+export declare const finish: (key: string) => void;

package/dist/types/dev-warning.d.ts

@@ -0,0 +1,4 @@
+export declare const getFormattedMessage: (message: string) => string[];
+export declare function log(type: 'error' | 'warn', message: string): void;
+export declare const warning: any;
+export declare const error: any;

package/dist/types/empty.d.ts

@@ -0,0 +1,2 @@
+export declare function noop(): void;
+export declare function identity<T>(value: T): T;

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { default as DragDropContext } from './view/drag-drop-context';
+export { default as Droppable } from './view/droppable';
+export { default as Draggable } from './view/draggable';
+export { useMouseSensor, useTouchSensor, useKeyboardSensor, } from './view/use-sensor-marshal';
+export { resetServerContext } from './view/drag-drop-context';
+export type { Id, TypeId, DraggableId, DroppableId, DraggableRubric, MovementMode, BeforeCapture, DragStart, DragUpdate, DropResult, Direction, ResponderProvided, Announce, DraggableLocation, OnBeforeCaptureResponder, OnBeforeDragStartResponder, OnDragStartResponder, OnDragUpdateResponder, OnDragEndResponder, SensorAPI, Sensor, TryGetLock, TryGetLockOptions, } from './types';
+export type { Provided as DroppableProvided, StateSnapshot as DroppableStateSnapshot, DroppableProps, } from './view/droppable/droppable-types';
+export type { Provided as DraggableProvided, StateSnapshot as DraggableStateSnapshot, DragHandleProps, DropAnimation, DraggableProps, DraggableStyle, DraggingStyle, NotDraggingStyle, ChildrenFn as DraggableChildrenFn, } from './view/draggable/draggable-types';

package/dist/types/invariant.d.ts

@@ -0,0 +1,4 @@
+export declare class RbdInvariant extends Error {
+    constructor(message: string);
+}
+export declare function invariant(condition: unknown, message?: string): asserts condition;

package/dist/types/native-with-fallback.d.ts

@@ -0,0 +1,10 @@
+type Map<T> = {
+    [key: string]: T;
+};
+export declare function isInteger(value: unknown): boolean;
+export declare function values<T>(map: Map<T>): T[];
+type PredicateFn<T> = (value: T) => boolean;
+export declare function findIndex<T>(list: Array<T>, predicate: PredicateFn<T>): number;
+export declare function find<T>(list: Array<T>, predicate: PredicateFn<T>): T | undefined;
+export declare function toArray(list: NodeListOf<HTMLElement>): Element[];
+export {};

package/dist/types/screen-reader-message-preset.d.ts

@@ -0,0 +1,9 @@
+import type { DragStart, DragUpdate, DropResult } from './types';
+export type MessagePreset = {
+    dragHandleUsageInstructions: string;
+    onDragStart: (start: DragStart) => string;
+    onDragUpdate: (update: DragUpdate) => string;
+    onDragEnd: (result: DropResult) => string;
+};
+declare const preset: MessagePreset;
+export default preset;

package/dist/types/state/action-creators.d.ts

@@ -0,0 +1,158 @@
+import type { Position } from 'css-box-model';
+import type { Critical, DraggableId, DroppableId, CompletedDrag, MovementMode, Viewport, DimensionMap, DropReason, Published } from '../types';
+export type BeforeInitialCaptureArgs = {
+    draggableId: DraggableId;
+    movementMode: MovementMode;
+};
+export type BeforeInitialCaptureAction = {
+    type: 'BEFORE_INITIAL_CAPTURE';
+    payload: BeforeInitialCaptureArgs;
+};
+export declare const beforeInitialCapture: (args: BeforeInitialCaptureArgs) => BeforeInitialCaptureAction;
+export type LiftArgs = {
+    id: DraggableId;
+    clientSelection: Position;
+    movementMode: MovementMode;
+};
+export type LiftAction = {
+    type: 'LIFT';
+    payload: LiftArgs;
+};
+export declare const lift: (args: LiftArgs) => LiftAction;
+export type InitialPublishArgs = {
+    critical: Critical;
+    dimensions: DimensionMap;
+    clientSelection: Position;
+    viewport: Viewport;
+    movementMode: MovementMode;
+};
+export type InitialPublishAction = {
+    type: 'INITIAL_PUBLISH';
+    payload: InitialPublishArgs;
+};
+export declare const initialPublish: (args: InitialPublishArgs) => InitialPublishAction;
+export type WhileDraggingPublishAction = {
+    type: 'PUBLISH_WHILE_DRAGGING';
+    payload: Published;
+};
+export declare const publishWhileDragging: (args: Published) => WhileDraggingPublishAction;
+export type CollectionStartingAction = {
+    type: 'COLLECTION_STARTING';
+    payload: null;
+};
+export declare const collectionStarting: () => CollectionStartingAction;
+export type UpdateDroppableScrollArgs = {
+    id: DroppableId;
+    newScroll: Position;
+};
+export type UpdateDroppableScrollAction = {
+    type: 'UPDATE_DROPPABLE_SCROLL';
+    payload: UpdateDroppableScrollArgs;
+};
+export declare const updateDroppableScroll: (args: UpdateDroppableScrollArgs) => UpdateDroppableScrollAction;
+export type UpdateDroppableIsEnabledArgs = {
+    id: DroppableId;
+    isEnabled: boolean;
+};
+export type UpdateDroppableIsEnabledAction = {
+    type: 'UPDATE_DROPPABLE_IS_ENABLED';
+    payload: UpdateDroppableIsEnabledArgs;
+};
+export declare const updateDroppableIsEnabled: (args: UpdateDroppableIsEnabledArgs) => UpdateDroppableIsEnabledAction;
+export type UpdateDroppableIsCombineEnabledArgs = {
+    id: DroppableId;
+    isCombineEnabled: boolean;
+};
+export type UpdateDroppableIsCombineEnabledAction = {
+    type: 'UPDATE_DROPPABLE_IS_COMBINE_ENABLED';
+    payload: UpdateDroppableIsCombineEnabledArgs;
+};
+export declare const updateDroppableIsCombineEnabled: (args: UpdateDroppableIsCombineEnabledArgs) => UpdateDroppableIsCombineEnabledAction;
+export type MoveArgs = {
+    client: Position;
+};
+export type MoveAction = {
+    type: 'MOVE';
+    payload: MoveArgs;
+};
+export declare const move: (args: MoveArgs) => MoveAction;
+type MoveByWindowScrollArgs = {
+    newScroll: Position;
+};
+export type MoveByWindowScrollAction = {
+    type: 'MOVE_BY_WINDOW_SCROLL';
+    payload: MoveByWindowScrollArgs;
+};
+export declare const moveByWindowScroll: (args: MoveByWindowScrollArgs) => MoveByWindowScrollAction;
+export type UpdateViewportMaxScrollArgs = {
+    maxScroll: Position;
+};
+type UpdateViewportMaxScrollAction = {
+    type: 'UPDATE_VIEWPORT_MAX_SCROLL';
+    payload: UpdateViewportMaxScrollArgs;
+};
+export declare const updateViewportMaxScroll: (args: UpdateViewportMaxScrollArgs) => UpdateViewportMaxScrollAction;
+export type MoveUpAction = {
+    type: 'MOVE_UP';
+    payload: null;
+};
+export declare const moveUp: () => MoveUpAction;
+export type MoveDownAction = {
+    type: 'MOVE_DOWN';
+    payload: null;
+};
+export declare const moveDown: () => MoveDownAction;
+export type MoveRightAction = {
+    type: 'MOVE_RIGHT';
+    payload: null;
+};
+export declare const moveRight: () => MoveRightAction;
+export type MoveLeftAction = {
+    type: 'MOVE_LEFT';
+    payload: null;
+};
+export declare const moveLeft: () => MoveLeftAction;
+type FlushAction = {
+    type: 'FLUSH';
+    payload: null;
+};
+export declare const flush: () => FlushAction;
+export type AnimateDropArgs = {
+    completed: CompletedDrag;
+    newHomeClientOffset: Position;
+    dropDuration: number;
+};
+export type DropAnimateAction = {
+    type: 'DROP_ANIMATE';
+    payload: AnimateDropArgs;
+};
+export declare const animateDrop: (args: AnimateDropArgs) => DropAnimateAction;
+export type DropCompleteArgs = {
+    completed: CompletedDrag;
+};
+export type DropCompleteAction = {
+    type: 'DROP_COMPLETE';
+    payload: DropCompleteArgs;
+};
+export declare const completeDrop: (args: DropCompleteArgs) => DropCompleteAction;
+type DropArgs = {
+    reason: DropReason;
+};
+export type DropAction = {
+    type: 'DROP';
+    payload: DropArgs;
+};
+export declare const drop: (args: DropArgs) => DropAction;
+export declare const cancel: () => DropAction;
+export type DropPendingAction = {
+    type: 'DROP_PENDING';
+    payload: DropArgs;
+};
+export declare const dropPending: (args: DropArgs) => DropPendingAction;
+export type DropAnimationFinishedAction = {
+    type: 'DROP_ANIMATION_FINISHED';
+    payload: null;
+};
+export declare const dropAnimationFinished: () => DropAnimationFinishedAction;
+export type Action = BeforeInitialCaptureAction | LiftAction | InitialPublishAction | WhileDraggingPublishAction | CollectionStartingAction | UpdateDroppableScrollAction | UpdateDroppableIsEnabledAction | UpdateDroppableIsCombineEnabledAction | MoveByWindowScrollAction | UpdateViewportMaxScrollAction | MoveAction | MoveUpAction | MoveDownAction | MoveRightAction | MoveLeftAction | DropPendingAction | DropAction | DropAnimateAction | DropAnimationFinishedAction | DropCompleteAction | FlushAction;
+export {};

package/dist/types/state/auto-scroller/auto-scroller-types.d.ts

@@ -0,0 +1,6 @@
+import type { State, DraggingState } from '../../types';
+export type AutoScroller = {
+    start: (state: DraggingState) => void;
+    stop: () => void;
+    scroll: (state: State) => void;
+};

package/dist/types/state/auto-scroller/can-scroll.d.ts

@@ -0,0 +1,19 @@
+import type { Position } from 'css-box-model';
+import type { DroppableDimension, Viewport } from '../../types';
+type CanPartiallyScrollArgs = {
+    max: Position;
+    current: Position;
+    change: Position;
+};
+type GetRemainderArgs = {
+    current: Position;
+    max: Position;
+    change: Position;
+};
+export declare const getOverlap: ({ current, max, change }: GetRemainderArgs) => Position | null;
+export declare const canPartiallyScroll: ({ max: rawMax, current, change, }: CanPartiallyScrollArgs) => boolean;
+export declare const canScrollWindow: (viewport: Viewport, change: Position) => boolean;
+export declare const getWindowOverlap: (viewport: Viewport, change: Position) => Position | null;
+export declare const canScrollDroppable: (droppable: DroppableDimension, change: Position) => boolean;
+export declare const getDroppableOverlap: (droppable: DroppableDimension, change: Position) => Position | null;
+export {};

package/dist/types/state/auto-scroller/fluid-scroller/config.d.ts

@@ -0,0 +1,11 @@
+declare const config: {
+    startFromPercentage: number;
+    maxScrollAtPercentage: number;
+    maxPixelScroll: number;
+    ease: (percentage: number) => number;
+    durationDampening: {
+        stopDampeningAt: number;
+        accelerateAt: number;
+    };
+};
+export default config;

package/dist/types/state/auto-scroller/fluid-scroller/get-best-scrollable-droppable.d.ts

@@ -0,0 +1,9 @@
+import { type Position } from 'css-box-model';
+import type { DroppableDimension, DroppableDimensionMap, DroppableId } from '../../../types';
+type Api = {
+    center: Position;
+    destination: DroppableId | null;
+    droppables: DroppableDimensionMap;
+};
+declare const _default: ({ center, destination, droppables, }: Api) => DroppableDimension | null | undefined;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-droppable-scroll-change.d.ts

@@ -0,0 +1,11 @@
+import type { Position, Rect } from 'css-box-model';
+import type { DroppableDimension } from '../../../types';
+type Args = {
+    droppable: DroppableDimension;
+    subject: Rect;
+    center: Position;
+    dragStartTime: number;
+    shouldUseTimeDampening: boolean;
+};
+declare const _default: ({ droppable, subject, center, dragStartTime, shouldUseTimeDampening, }: Args) => Position | null;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-percentage.d.ts

@@ -0,0 +1,7 @@
+type Args = {
+    startOfRange: number;
+    endOfRange: number;
+    current: number;
+};
+declare const _default: ({ startOfRange, endOfRange, current }: Args) => number;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/adjust-for-size-limits.d.ts

@@ -0,0 +1,8 @@
+import type { Rect, Position } from 'css-box-model';
+type Args = {
+    container: Rect;
+    subject: Rect;
+    proposedScroll: Position;
+};
+declare const _default: ({ container, subject, proposedScroll }: Args) => Position | null | undefined;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/dampen-value-by-time.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (proposedScroll: number, dragStartTime: number) => number;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/get-distance-thresholds.d.ts

@@ -0,0 +1,8 @@
+import type { Rect } from 'css-box-model';
+import type { Axis } from '../../../../../types';
+export type DistanceThresholds = {
+    startScrollingFrom: number;
+    maxScrollValueAt: number;
+};
+declare const _default: (container: Rect, axis: Axis) => DistanceThresholds;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/get-value-from-distance.d.ts

@@ -0,0 +1,3 @@
+import { type DistanceThresholds } from './get-distance-thresholds';
+declare const _default: (distanceToEdge: number, thresholds: DistanceThresholds) => number;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/get-value.d.ts

@@ -0,0 +1,9 @@
+import { type DistanceThresholds } from './get-distance-thresholds';
+type Args = {
+    distanceToEdge: number;
+    thresholds: DistanceThresholds;
+    dragStartTime: number;
+    shouldUseTimeDampening: boolean;
+};
+declare const _default: ({ distanceToEdge, thresholds, dragStartTime, shouldUseTimeDampening, }: Args) => number;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/index.d.ts

@@ -0,0 +1,11 @@
+import type { Rect, Spacing } from 'css-box-model';
+import type { Axis } from '../../../../../types';
+type GetOnAxisArgs = {
+    container: Rect;
+    distanceToEdges: Spacing;
+    dragStartTime: number;
+    axis: Axis;
+    shouldUseTimeDampening: boolean;
+};
+declare const _default: ({ container, distanceToEdges, dragStartTime, axis, shouldUseTimeDampening, }: GetOnAxisArgs) => number;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/get-scroll-on-axis/min-scroll.d.ts

@@ -0,0 +1,2 @@
+declare const _default: 1;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-scroll/index.d.ts

@@ -0,0 +1,10 @@
+import type { Position, Rect } from 'css-box-model';
+type Args = {
+    dragStartTime: number;
+    container: Rect;
+    subject: Rect;
+    center: Position;
+    shouldUseTimeDampening: boolean;
+};
+declare const _default: ({ dragStartTime, container, subject, center, shouldUseTimeDampening, }: Args) => Position | null;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/get-window-scroll-change.d.ts

@@ -0,0 +1,11 @@
+import type { Position, Rect } from 'css-box-model';
+import type { Viewport } from '../../../types';
+type Args = {
+    viewport: Viewport;
+    subject: Rect;
+    center: Position;
+    dragStartTime: number;
+    shouldUseTimeDampening: boolean;
+};
+declare const _default: ({ viewport, subject, center, dragStartTime, shouldUseTimeDampening, }: Args) => Position | null;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/index.d.ts

@@ -0,0 +1,13 @@
+import { type Position } from 'css-box-model';
+import type { DraggingState, DroppableId } from '../../../types';
+export type PublicArgs = {
+    scrollWindow: (change: Position) => void;
+    scrollDroppable: (id: DroppableId, change: Position) => void;
+};
+export type FluidScroller = {
+    scroll: (state: DraggingState) => void;
+    start: (state: DraggingState) => void;
+    stop: () => void;
+};
+declare const _default: ({ scrollWindow, scrollDroppable, }: PublicArgs) => FluidScroller;
+export default _default;

package/dist/types/state/auto-scroller/fluid-scroller/scroll.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import type { DraggingState, DroppableId } from '../../../types';
+type Args = {
+    state: DraggingState;
+    dragStartTime: number;
+    shouldUseTimeDampening: boolean;
+    scrollWindow: (scroll: Position) => void;
+    scrollDroppable: (id: DroppableId, scroll: Position) => void;
+};
+declare const _default: ({ state, dragStartTime, shouldUseTimeDampening, scrollWindow, scrollDroppable, }: Args) => void;
+export default _default;

package/dist/types/state/auto-scroller/index.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import type { AutoScroller } from './auto-scroller-types';
+import type { DroppableId } from '../../types';
+import type { MoveArgs } from '../action-creators';
+export type Args = {
+    scrollWindow: (offset: Position) => void;
+    scrollDroppable: (id: DroppableId, change: Position) => void;
+    move: (args: MoveArgs) => unknown;
+};
+declare const _default: ({ scrollDroppable, scrollWindow, move, }: Args) => AutoScroller;
+export default _default;

package/dist/types/state/auto-scroller/jump-scroller.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import { type MoveArgs } from '../action-creators';
+import type { DraggingState, DroppableId } from '../../types';
+type Args = {
+    scrollDroppable: (id: DroppableId, change: Position) => void;
+    scrollWindow: (offset: Position) => void;
+    move: (args: MoveArgs) => unknown;
+};
+export type JumpScroller = (state: DraggingState) => void;
+declare const _default: ({ move, scrollDroppable, scrollWindow, }: Args) => JumpScroller;
+export default _default;

package/dist/types/state/axis.d.ts

@@ -0,0 +1,3 @@
+import type { HorizontalAxis, VerticalAxis } from '../types';
+export declare const vertical: VerticalAxis;
+export declare const horizontal: HorizontalAxis;

package/dist/types/state/calculate-drag-impact/calculate-reorder-impact.d.ts

@@ -0,0 +1,13 @@
+import type { DraggableDimension, DroppableDimension, DragImpact, DisplacementGroups, Viewport, DisplacedBy } from '../../types';
+type Args = {
+    draggable: DraggableDimension;
+    insideDestination: DraggableDimension[];
+    destination: DroppableDimension;
+    viewport: Viewport;
+    displacedBy: DisplacedBy;
+    last: DisplacementGroups;
+    index: number | null;
+    forceShouldAnimate?: boolean;
+};
+export default function calculateReorderImpact({ draggable, insideDestination, destination, viewport, displacedBy, last, index, forceShouldAnimate, }: Args): DragImpact;
+export {};

package/dist/types/state/can-start-drag.d.ts

@@ -0,0 +1,3 @@
+import type { State, DraggableId } from '../types';
+declare const _default: (state: State, id: DraggableId) => boolean;
+export default _default;

package/dist/types/state/create-store.d.ts

@@ -0,0 +1,16 @@
+import type { DimensionMarshal } from './dimension-marshal/dimension-marshal-types';
+import type { FocusMarshal } from '../view/use-focus-marshal/focus-marshal-types';
+import type { StyleMarshal } from '../view/use-style-marshal/style-marshal-types';
+import type { AutoScroller } from './auto-scroller/auto-scroller-types';
+import type { Responders, Announce } from '../types';
+import type { Store } from './store-types';
+type Args = {
+    dimensionMarshal: DimensionMarshal;
+    focusMarshal: FocusMarshal;
+    styleMarshal: StyleMarshal;
+    getResponders: () => Responders;
+    announce: Announce;
+    autoScroller: AutoScroller;
+};
+declare const _default: ({ dimensionMarshal, focusMarshal, styleMarshal, getResponders, announce, autoScroller, }: Args) => Store;
+export default _default;

package/dist/types/state/did-start-after-critical.d.ts

@@ -0,0 +1,2 @@
+import type { DraggableId, LiftEffect } from '../types';
+export default function didStartAfterCritical(draggableId: DraggableId, afterCritical: LiftEffect): boolean;

package/dist/types/state/dimension-marshal/dimension-marshal-types.d.ts

@@ -0,0 +1,23 @@
+import type { Position } from 'css-box-model';
+import type { UpdateDroppableScrollArgs, UpdateDroppableIsEnabledArgs, UpdateDroppableIsCombineEnabledArgs } from '../action-creators';
+import type { DroppableId, Critical, DimensionMap, LiftRequest, Published, Viewport } from '../../types';
+export type StartPublishingResult = {
+    critical: Critical;
+    dimensions: DimensionMap;
+    viewport: Viewport;
+};
+export type DimensionMarshal = {
+    updateDroppableIsEnabled: (id: DroppableId, isEnabled: boolean) => void;
+    updateDroppableIsCombineEnabled: (id: DroppableId, isEnabled: boolean) => void;
+    updateDroppableScroll: (id: DroppableId, newScroll: Position) => void;
+    scrollDroppable: (id: DroppableId, change: Position) => void;
+    startPublishing: (request: LiftRequest) => StartPublishingResult;
+    stopPublishing: () => void;
+};
+export type Callbacks = {
+    collectionStarting: () => unknown;
+    publishWhileDragging: (args: Published) => unknown;
+    updateDroppableScroll: (args: UpdateDroppableScrollArgs) => unknown;
+    updateDroppableIsEnabled: (args: UpdateDroppableIsEnabledArgs) => unknown;
+    updateDroppableIsCombineEnabled: (args: UpdateDroppableIsCombineEnabledArgs) => unknown;
+};

package/dist/types/state/dimension-marshal/dimension-marshal.d.ts

@@ -0,0 +1,4 @@
+import type { DimensionMarshal, Callbacks } from './dimension-marshal-types';
+import type { Registry } from '../registry/registry-types';
+declare const _default: (registry: Registry, callbacks: Callbacks) => DimensionMarshal;
+export default _default;

package/dist/types/state/dimension-marshal/get-initial-publish.d.ts

@@ -0,0 +1,10 @@
+import type { StartPublishingResult } from './dimension-marshal-types';
+import type { Registry } from '../registry/registry-types';
+import type { ScrollOptions, Critical } from '../../types';
+type Args = {
+    critical: Critical;
+    scrollOptions: ScrollOptions;
+    registry: Registry;
+};
+declare const _default: ({ critical, scrollOptions, registry, }: Args) => StartPublishingResult;
+export default _default;

package/dist/types/state/dimension-marshal/while-dragging-publisher.d.ts

@@ -0,0 +1,17 @@
+import type { Published } from '../../types';
+import type { Registry, DraggableEntry } from '../registry/registry-types';
+export type WhileDraggingPublisher = {
+    add: (entry: DraggableEntry) => void;
+    remove: (entry: DraggableEntry) => void;
+    stop: () => void;
+};
+type Callbacks = {
+    publish: (args: Published) => unknown;
+    collectionStarting: () => unknown;
+};
+type Args = {
+    registry: Registry;
+    callbacks: Callbacks;
+};
+export default function createPublisher({ registry, callbacks, }: Args): WhileDraggingPublisher;
+export {};

package/dist/types/state/dimension-structures.d.ts

@@ -0,0 +1,5 @@
+import type { DroppableDimension, DroppableDimensionMap, DraggableDimension, DraggableDimensionMap } from '../types';
+export declare const toDroppableMap: import("memoize-one").MemoizedFn<(droppables: DroppableDimension[]) => DroppableDimensionMap>;
+export declare const toDraggableMap: import("memoize-one").MemoizedFn<(draggables: DraggableDimension[]) => DraggableDimensionMap>;
+export declare const toDroppableList: import("memoize-one").MemoizedFn<(droppables: DroppableDimensionMap) => DroppableDimension[]>;
+export declare const toDraggableList: import("memoize-one").MemoizedFn<(draggables: DraggableDimensionMap) => DraggableDimension[]>;

package/dist/types/state/droppable/get-droppable.d.ts

@@ -0,0 +1,21 @@
+import { type BoxModel, type Position } from 'css-box-model';
+import type { DroppableDimension, DroppableDescriptor, ScrollSize } from '../../types';
+export type Closest = {
+    client: BoxModel;
+    page: BoxModel;
+    scroll: Position;
+    scrollSize: ScrollSize;
+    shouldClipSubject: boolean;
+};
+type Args = {
+    descriptor: DroppableDescriptor;
+    isEnabled: boolean;
+    isCombineEnabled: boolean;
+    isFixedOnPage: boolean;
+    direction: 'vertical' | 'horizontal';
+    client: BoxModel;
+    page: BoxModel;
+    closest?: Closest | null;
+};
+declare const _default: ({ descriptor, isEnabled, isCombineEnabled, isFixedOnPage, direction, client, page, closest, }: Args) => DroppableDimension;
+export default _default;

package/dist/types/state/droppable/is-home-of.d.ts

@@ -0,0 +1,3 @@
+import type { DraggableDimension, DroppableDimension } from '../../types';
+declare const _default: (draggable: DraggableDimension, destination: DroppableDimension) => boolean;
+export default _default;

package/dist/types/state/droppable/scroll-droppable.d.ts

@@ -0,0 +1,4 @@
+import { type Position } from 'css-box-model';
+import type { DroppableDimension } from '../../types';
+declare const _default: (droppable: DroppableDimension, newScroll: Position) => DroppableDimension;
+export default _default;

package/dist/types/state/droppable/should-use-placeholder.d.ts

@@ -0,0 +1,3 @@
+import type { DraggableDescriptor, DragImpact } from '../../types';
+declare const _default: (descriptor: DraggableDescriptor, impact: DragImpact) => boolean;
+export default _default;

package/dist/types/state/droppable/util/clip.d.ts

@@ -0,0 +1,3 @@
+import { type Rect, type Spacing } from 'css-box-model';
+declare const _default: (frame: Spacing, subject: Spacing) => Rect | null;
+export default _default;