@helpdice/draggable 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,10 @@
+import { type BoxModel } from 'css-box-model';
+import type { Axis, Scrollable, DroppableSubject, PlaceholderInSubject } from '../../../types';
+type Args = {
+    page: BoxModel;
+    withPlaceholder: PlaceholderInSubject | null;
+    axis: Axis;
+    frame: Scrollable | null;
+};
+declare const _default: ({ page, withPlaceholder, axis, frame, }: Args) => DroppableSubject;
+export default _default;

package/dist/types/state/droppable/what-is-dragged-over-from-result.d.ts

@@ -0,0 +1,3 @@
+import type { DroppableId, DropResult } from '../../types';
+declare const _default: (result: DropResult) => DroppableId | null;
+export default _default;

package/dist/types/state/droppable/what-is-dragged-over.d.ts

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

package/dist/types/state/droppable/with-placeholder.d.ts

@@ -0,0 +1,3 @@
+import type { DroppableDimension, DraggableDimension, DraggableDimensionMap } from '../../types';
+export declare const addPlaceholder: (droppable: DroppableDimension, draggable: DraggableDimension, draggables: DraggableDimensionMap) => DroppableDimension;
+export declare const removePlaceholder: (droppable: DroppableDimension) => DroppableDimension;

package/dist/types/state/get-center-from-impact/get-client-border-box-center/get-client-from-page-border-box-center.d.ts

@@ -0,0 +1,9 @@
+import type { Position } from 'css-box-model';
+import type { Viewport, DraggableDimension } from '../../../types';
+type Args = {
+    pageBorderBoxCenter: Position;
+    draggable: DraggableDimension;
+    viewport: Viewport;
+};
+declare const _default: ({ pageBorderBoxCenter, draggable, viewport, }: Args) => Position;
+export default _default;

package/dist/types/state/get-center-from-impact/get-client-border-box-center/index.d.ts

@@ -0,0 +1,12 @@
+import type { Position } from 'css-box-model';
+import type { DroppableDimension, Viewport, DragImpact, DraggableDimension, DraggableDimensionMap, LiftEffect } from '../../../types';
+type Args = {
+    impact: DragImpact;
+    draggable: DraggableDimension;
+    droppable: DroppableDimension;
+    draggables: DraggableDimensionMap;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ impact, draggable, droppable, draggables, viewport, afterCritical, }: Args) => Position;
+export default _default;

package/dist/types/state/get-center-from-impact/get-page-border-box-center/index.d.ts

@@ -0,0 +1,11 @@
+import type { Position } from 'css-box-model';
+import type { DragImpact, DraggableDimension, DroppableDimension, DraggableDimensionMap, LiftEffect } from '../../../types';
+type Args = {
+    impact: DragImpact;
+    afterCritical: LiftEffect;
+    draggable: DraggableDimension;
+    droppable: DroppableDimension | null;
+    draggables: DraggableDimensionMap;
+};
+declare const _default: (args: Args) => Position;
+export default _default;

package/dist/types/state/get-center-from-impact/get-page-border-box-center/when-combining.d.ts

@@ -0,0 +1,9 @@
+import { type Position } from 'css-box-model';
+import type { DraggableDimensionMap, LiftEffect, DragImpact } from '../../../types';
+type Args = {
+    impact: DragImpact;
+    draggables: DraggableDimensionMap;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ afterCritical, impact, draggables }: Args) => Position;
+export default _default;

package/dist/types/state/get-center-from-impact/get-page-border-box-center/when-reordering.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import type { DragImpact, DraggableDimension, DraggableDimensionMap, DroppableDimension, LiftEffect } from '../../../types';
+type NewHomeArgs = {
+    impact: DragImpact;
+    draggable: DraggableDimension;
+    draggables: DraggableDimensionMap;
+    droppable: DroppableDimension;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ impact, draggable, draggables, droppable, afterCritical, }: NewHomeArgs) => Position;
+export default _default;

package/dist/types/state/get-center-from-impact/move-relative-to.d.ts

@@ -0,0 +1,16 @@
+import type { Position, BoxModel } from 'css-box-model';
+import type { Axis } from '../../types';
+type Args = {
+    axis: Axis;
+    moveRelativeTo: BoxModel;
+    isMoving: BoxModel;
+};
+export declare const goAfter: ({ axis, moveRelativeTo, isMoving }: Args) => Position;
+export declare const goBefore: ({ axis, moveRelativeTo, isMoving }: Args) => Position;
+type GoIntoArgs = {
+    axis: Axis;
+    moveInto: BoxModel;
+    isMoving: BoxModel;
+};
+export declare const goIntoStart: ({ axis, moveInto, isMoving, }: GoIntoArgs) => Position;
+export {};

package/dist/types/state/get-combined-item-displacement.d.ts

@@ -0,0 +1,10 @@
+import type { Position } from 'css-box-model';
+import type { DisplacementGroups, LiftEffect, DraggableId, DisplacedBy } from '../types';
+type Args = {
+    displaced: DisplacementGroups;
+    afterCritical: LiftEffect;
+    combineWith: DraggableId;
+    displacedBy: DisplacedBy;
+};
+declare const _default: ({ displaced, afterCritical, combineWith, displacedBy, }: Args) => Position;
+export default _default;

package/dist/types/state/get-displaced-by.d.ts

@@ -0,0 +1,4 @@
+import { type Position } from 'css-box-model';
+import type { Axis, DisplacedBy } from '../types';
+declare const _default: import("memoize-one").MemoizedFn<(axis: Axis, displaceBy: Position) => DisplacedBy>;
+export default _default;

package/dist/types/state/get-displacement-groups.d.ts

@@ -0,0 +1,12 @@
+import { type Rect } from 'css-box-model';
+import type { DraggableDimension, DroppableDimension, DisplacementGroups, DisplacedBy } from '../types';
+type Args = {
+    afterDragging: DraggableDimension[];
+    destination: DroppableDimension;
+    displacedBy: DisplacedBy;
+    last: DisplacementGroups | null;
+    viewport: Rect;
+    forceShouldAnimate?: boolean;
+};
+export default function getDisplacementGroups({ afterDragging, destination, displacedBy, viewport, forceShouldAnimate, last, }: Args): DisplacementGroups;
+export {};

package/dist/types/state/get-drag-impact/get-combine-impact.d.ts

@@ -0,0 +1,13 @@
+import type { Rect } from 'css-box-model';
+import type { DraggableDimension, DroppableDimension, DragImpact, LiftEffect } from '../../types';
+type Args = {
+    draggable: DraggableDimension;
+    pageBorderBoxWithDroppableScroll: Rect;
+    previousImpact: DragImpact;
+    destination: DroppableDimension;
+    insideDestination: DraggableDimension[];
+    afterCritical: LiftEffect;
+};
+export declare const combineThresholdDivisor: number;
+declare const _default: ({ draggable, pageBorderBoxWithDroppableScroll: targetRect, previousImpact, destination, insideDestination, afterCritical, }: Args) => DragImpact | null;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { type Rect } from 'css-box-model';
+import type { DraggableDimension, DroppableDimension, DragImpact, DisplacementGroups, Viewport, LiftEffect } from '../../types';
+type Args = {
+    pageBorderBoxWithDroppableScroll: Rect;
+    draggable: DraggableDimension;
+    destination: DroppableDimension;
+    insideDestination: DraggableDimension[];
+    last: DisplacementGroups;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ pageBorderBoxWithDroppableScroll: targetRect, draggable, destination, insideDestination, last, viewport, afterCritical, }: Args) => DragImpact;
+export default _default;

package/dist/types/state/get-drag-impact/index.d.ts

@@ -0,0 +1,13 @@
+import { type Position } from 'css-box-model';
+import type { DraggableDimension, DraggableDimensionMap, DroppableDimensionMap, DragImpact, Viewport, LiftEffect } from '../../types';
+type Args = {
+    pageOffset: Position;
+    draggable: DraggableDimension;
+    draggables: DraggableDimensionMap;
+    droppables: DroppableDimensionMap;
+    previousImpact: DragImpact;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ pageOffset, draggable, draggables, droppables, previousImpact, viewport, afterCritical, }: Args) => DragImpact;
+export default _default;

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

@@ -0,0 +1,3 @@
+import type { DraggableDimension, DroppableId, DraggableDimensionMap } from '../types';
+declare const _default: import("memoize-one").MemoizedFn<(droppableId: DroppableId, draggables: DraggableDimensionMap) => DraggableDimension[]>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { type Rect } from 'css-box-model';
+import type { DroppableDimensionMap, DroppableId, DraggableDimension } from '../types';
+type Args = {
+    pageBorderBox: Rect;
+    draggable: DraggableDimension;
+    droppables: DroppableDimensionMap;
+};
+export default function getDroppableOver({ pageBorderBox, draggable, droppables, }: Args): DroppableId | null;
+export {};

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

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

package/dist/types/state/get-home-location.d.ts

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

package/dist/types/state/get-impact-location.d.ts

@@ -0,0 +1,3 @@
+import type { DragImpact, DraggableLocation, Combine } from '../types';
+export declare function tryGetDestination(impact: DragImpact): DraggableLocation | null;
+export declare function tryGetCombine(impact: DragImpact): Combine | null;

package/dist/types/state/get-is-displaced.d.ts

@@ -0,0 +1,7 @@
+import type { DisplacementGroups, DraggableId } from '../types';
+type Args = {
+    displaced: DisplacementGroups;
+    id: DraggableId;
+};
+export default function getIsDisplaced({ displaced, id }: Args): boolean;
+export {};

package/dist/types/state/get-lift-effect.d.ts

@@ -0,0 +1,13 @@
+import type { DraggableDimension, DroppableDimension, DraggableDimensionMap, DragImpact, Viewport, LiftEffect } from '../types';
+type Args = {
+    draggable: DraggableDimension;
+    home: DroppableDimension;
+    draggables: DraggableDimensionMap;
+    viewport: Viewport;
+};
+type Result = {
+    afterCritical: LiftEffect;
+    impact: DragImpact;
+};
+declare const _default: ({ draggable, home, draggables, viewport }: Args) => Result;
+export default _default;

package/dist/types/state/get-max-scroll.d.ts

@@ -0,0 +1,9 @@
+import { type Position } from 'css-box-model';
+type Args = {
+    scrollHeight: number;
+    scrollWidth: number;
+    height: number;
+    width: number;
+};
+declare const _default: ({ scrollHeight, scrollWidth, height, width, }: Args) => Position;
+export default _default;

package/dist/types/state/is-movement-allowed.d.ts

@@ -0,0 +1,2 @@
+import type { CollectingState, DraggingState, State } from '../types';
+export default function isMovementAllowed(state: State): state is DraggingState | CollectingState;

package/dist/types/state/is-within.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (lowerBound: number, upperBound: number) => ((arg: number) => boolean);
+export default _default;

package/dist/types/state/middleware/auto-scroll.d.ts

@@ -0,0 +1,4 @@
+import type { AutoScroller } from '../auto-scroller/auto-scroller-types';
+import type { Action, Dispatch, MiddlewareStore } from '../store-types';
+declare const _default: (autoScroller: AutoScroller) => (store: MiddlewareStore) => (next: Dispatch) => (action: Action) => any;
+export default _default;

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

@@ -0,0 +1,4 @@
+import type { Action, Dispatch } from '../store-types';
+import type { DimensionMarshal } from '../dimension-marshal/dimension-marshal-types';
+declare const _default: (marshal: DimensionMarshal) => () => (next: Dispatch) => (action: Action) => any;
+export default _default;

package/dist/types/state/middleware/drop/drop-animation-finish-middleware.d.ts

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

package/dist/types/state/middleware/drop/drop-animation-flush-on-scroll-middleware.d.ts

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

package/dist/types/state/middleware/drop/drop-middleware.d.ts

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

package/dist/types/state/middleware/drop/get-drop-duration.d.ts

@@ -0,0 +1,9 @@
+import type { Position } from 'css-box-model';
+import type { DropReason } from '../../../types';
+type GetDropDurationArgs = {
+    current: Position;
+    destination: Position;
+    reason: DropReason;
+};
+declare const _default: ({ current, destination, reason, }: GetDropDurationArgs) => number;
+export default _default;

package/dist/types/state/middleware/drop/get-drop-impact.d.ts

@@ -0,0 +1,16 @@
+import type { DropReason, DragImpact, Viewport, DroppableDimension, DraggableDimensionMap, LiftEffect } from '../../../types';
+type Args = {
+    draggables: DraggableDimensionMap;
+    home: DroppableDimension;
+    reason: DropReason;
+    lastImpact: DragImpact;
+    onLiftImpact: DragImpact;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+export type Result = {
+    impact: DragImpact;
+    didDropInsideDroppable: boolean;
+};
+declare const _default: ({ draggables, reason, lastImpact, home, viewport, onLiftImpact, }: Args) => Result;
+export default _default;

package/dist/types/state/middleware/drop/get-new-home-client-offset.d.ts

@@ -0,0 +1,11 @@
+import type { Position } from 'css-box-model';
+import type { Viewport, DragImpact, DimensionMap, DraggableDimension, LiftEffect } from '../../../types';
+type Args = {
+    impact: DragImpact;
+    draggable: DraggableDimension;
+    dimensions: DimensionMap;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ impact, draggable, dimensions, viewport, afterCritical, }: Args) => Position;
+export default _default;

package/dist/types/state/middleware/drop/index.d.ts

@@ -0,0 +1 @@
+export { default } from './drop-middleware';

package/dist/types/state/middleware/focus.d.ts

@@ -0,0 +1,4 @@
+import type { Action, Dispatch } from '../store-types';
+import type { FocusMarshal } from '../../view/use-focus-marshal/focus-marshal-types';
+declare const _default: (marshal: FocusMarshal) => () => (next: Dispatch) => (action: Action) => any;
+export default _default;

package/dist/types/state/middleware/lift.d.ts

@@ -0,0 +1,4 @@
+import type { DimensionMarshal } from '../dimension-marshal/dimension-marshal-types';
+import type { MiddlewareStore, Action, Dispatch } from '../store-types';
+declare const _default: (marshal: DimensionMarshal) => ({ getState, dispatch, }: MiddlewareStore) => (next: Dispatch) => (action: Action) => any;
+export default _default;

package/dist/types/state/middleware/pending-drop.d.ts

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

package/dist/types/state/middleware/responders/async-marshal.d.ts

@@ -0,0 +1,9 @@
+export type AsyncMarshal = {
+    add: (fn: Function) => void;
+    flush: () => void;
+};
+declare const _default: () => {
+    add: (fn: Function) => void;
+    flush: () => void;
+};
+export default _default;

package/dist/types/state/middleware/responders/expiring-announce.d.ts

@@ -0,0 +1,6 @@
+import type { Announce } from '../../../types';
+export type ExpiringAnnounce = Announce & {
+    wasCalled: () => boolean;
+};
+declare const _default: (announce: Announce) => ExpiringAnnounce;
+export default _default;

package/dist/types/state/middleware/responders/index.d.ts

@@ -0,0 +1 @@
+export { default } from './responders-middleware';

package/dist/types/state/middleware/responders/is-equal.d.ts

@@ -0,0 +1,4 @@
+import type { Critical, DraggableLocation, Combine } from '../../../types';
+export declare const areLocationsEqual: (first: DraggableLocation | null, second: DraggableLocation | null) => boolean;
+export declare const isCombineEqual: (first: Combine | null, second: Combine | null) => boolean;
+export declare const isCriticalEqual: (first: Critical, second: Critical) => boolean;

package/dist/types/state/middleware/responders/publisher.d.ts

@@ -0,0 +1,17 @@
+import type { DropResult, Responders, Critical, DragImpact, DraggableLocation, Combine, Announce, MovementMode, DraggableId } from '../../../types';
+export type WhileDragging = {
+    mode: MovementMode;
+    lastCritical: Critical;
+    lastCombine: Combine | null;
+    lastLocation: DraggableLocation | null;
+};
+declare const _default: (getResponders: () => Responders, announce: Announce) => {
+    beforeCapture: (draggableId: DraggableId, mode: MovementMode) => void;
+    beforeStart: (critical: Critical, mode: MovementMode) => void;
+    start: (critical: Critical, mode: MovementMode) => void;
+    update: (critical: Critical, impact: DragImpact) => void;
+    flush: () => void;
+    drop: (result: DropResult) => void;
+    abort: () => void;
+};
+export default _default;

package/dist/types/state/middleware/responders/responders-middleware.d.ts

@@ -0,0 +1,4 @@
+import type { Responders, Announce } from '../../../types';
+import type { Action, MiddlewareStore, Dispatch } from '../../store-types';
+declare const _default: (getResponders: () => Responders, announce: Announce) => (store: MiddlewareStore) => (next: Dispatch) => (action: Action) => any;
+export default _default;

package/dist/types/state/middleware/scroll-listener.d.ts

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

package/dist/types/state/middleware/style.d.ts

@@ -0,0 +1,4 @@
+import type { Action, Dispatch } from '../store-types';
+import type { StyleMarshal } from '../../view/use-style-marshal/style-marshal-types';
+declare const _default: (marshal: StyleMarshal) => () => (next: Dispatch) => (action: Action) => any;
+export default _default;

package/dist/types/state/middleware/util/validate-dimensions.d.ts

@@ -0,0 +1,2 @@
+import type { Critical, DimensionMap } from '../../../types';
+export default function validateDimensions(critical: Critical, dimensions: DimensionMap): void;

package/dist/types/state/move-in-direction/index.d.ts

@@ -0,0 +1,8 @@
+import type { PublicResult } from './move-in-direction-types';
+import type { DraggingState } from '../../types';
+type Args = {
+    state: DraggingState;
+    type: 'MOVE_UP' | 'MOVE_RIGHT' | 'MOVE_DOWN' | 'MOVE_LEFT';
+};
+declare const _default: ({ state, type }: Args) => PublicResult | null;
+export default _default;

package/dist/types/state/move-in-direction/move-cross-axis/get-best-cross-axis-droppable.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import type { DroppableDimension, DroppableDimensionMap, Viewport } from '../../../types';
+type GetBestDroppableArgs = {
+    isMovingForward: boolean;
+    pageBorderBoxCenter: Position;
+    source: DroppableDimension;
+    droppables: DroppableDimensionMap;
+    viewport: Viewport;
+};
+declare const _default: ({ isMovingForward, pageBorderBoxCenter, source, droppables, viewport, }: GetBestDroppableArgs) => DroppableDimension | null;
+export default _default;

package/dist/types/state/move-in-direction/move-cross-axis/get-closest-draggable.d.ts

@@ -0,0 +1,11 @@
+import { type Position } from 'css-box-model';
+import type { Viewport, DraggableDimension, DroppableDimension, LiftEffect } from '../../../types';
+type Args = {
+    pageBorderBoxCenter: Position;
+    viewport: Viewport;
+    destination: DroppableDimension;
+    insideDestination: DraggableDimension[];
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ pageBorderBoxCenter, viewport, destination, insideDestination, afterCritical, }: Args) => DraggableDimension | null;
+export default _default;

package/dist/types/state/move-in-direction/move-cross-axis/index.d.ts

@@ -0,0 +1,15 @@
+import { type Position } from 'css-box-model';
+import type { PublicResult } from '../move-in-direction-types';
+import type { DroppableDimension, DraggableDimension, DraggableDimensionMap, DroppableDimensionMap, Viewport, LiftEffect } from '../../../types';
+type Args = {
+    isMovingForward: boolean;
+    previousPageBorderBoxCenter: Position;
+    draggable: DraggableDimension;
+    isOver: DroppableDimension;
+    draggables: DraggableDimensionMap;
+    droppables: DroppableDimensionMap;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ isMovingForward, previousPageBorderBoxCenter, draggable, isOver, draggables, droppables, viewport, afterCritical, }: Args) => PublicResult | null;
+export default _default;

package/dist/types/state/move-in-direction/move-cross-axis/move-to-new-droppable.d.ts

@@ -0,0 +1,14 @@
+import type { Position } from 'css-box-model';
+import type { DragImpact, DraggableDimension, DraggableDimensionMap, DroppableDimension, Viewport, LiftEffect } from '../../../types';
+type Args = {
+    previousPageBorderBoxCenter: Position;
+    moveRelativeTo: DraggableDimension | null;
+    insideDestination: DraggableDimension[];
+    draggable: DraggableDimension;
+    draggables: DraggableDimensionMap;
+    destination: DroppableDimension;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ previousPageBorderBoxCenter, moveRelativeTo, insideDestination, draggable, draggables, destination, viewport, afterCritical, }: Args) => DragImpact | null;
+export default _default;

package/dist/types/state/move-in-direction/move-cross-axis/without-starting-displacement.d.ts

@@ -0,0 +1,4 @@
+import type { Position, Spacing } from 'css-box-model';
+import type { DraggableDimension, LiftEffect } from '../../../types';
+export declare const getCurrentPageBorderBoxCenter: (draggable: DraggableDimension, afterCritical: LiftEffect) => Position;
+export declare const getCurrentPageBorderBox: (draggable: DraggableDimension, afterCritical: LiftEffect) => Spacing;

package/dist/types/state/move-in-direction/move-in-direction-types.d.ts

@@ -0,0 +1,7 @@
+import type { Position } from 'css-box-model';
+import type { DragImpact } from '../../types';
+export type PublicResult = {
+    clientSelection: Position;
+    impact: DragImpact;
+    scrollJumpRequest: Position | null;
+};

package/dist/types/state/move-in-direction/move-to-next-place/index.d.ts

@@ -0,0 +1,16 @@
+import type { Position } from 'css-box-model';
+import type { DroppableDimension, DraggableDimension, DraggableDimensionMap, DragImpact, Viewport, LiftEffect } from '../../../types';
+import type { PublicResult } from '../move-in-direction-types';
+type Args = {
+    isMovingForward: boolean;
+    draggable: DraggableDimension;
+    destination: DroppableDimension;
+    draggables: DraggableDimensionMap;
+    previousImpact: DragImpact;
+    viewport: Viewport;
+    previousClientSelection: Position;
+    previousPageBorderBoxCenter: Position;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ isMovingForward, draggable, destination, draggables, previousImpact, viewport, previousPageBorderBoxCenter, previousClientSelection, afterCritical, }: Args) => PublicResult | null;
+export default _default;

package/dist/types/state/move-in-direction/move-to-next-place/is-totally-visible-in-new-location.d.ts

@@ -0,0 +1,12 @@
+import { type Position, type Rect } from 'css-box-model';
+import type { DraggableDimension, DroppableDimension } from '../../../types';
+type Args = {
+    draggable: DraggableDimension;
+    destination: DroppableDimension;
+    newPageBorderBoxCenter: Position;
+    viewport: Rect;
+    withDroppableDisplacement: false;
+    onlyOnMainAxis?: boolean;
+};
+declare const _default: ({ draggable, destination, newPageBorderBoxCenter, viewport, withDroppableDisplacement, onlyOnMainAxis, }: Args) => boolean;
+export default _default;

package/dist/types/state/move-in-direction/move-to-next-place/move-to-next-combine/index.d.ts

@@ -0,0 +1,10 @@
+import type { DraggableDimension, DroppableDimension, DragImpact } from '../../../../types';
+export type Args = {
+    isMovingForward: boolean;
+    draggable: DraggableDimension;
+    destination: DroppableDimension;
+    insideDestination: DraggableDimension[];
+    previousImpact: DragImpact;
+};
+declare const _default: ({ isMovingForward, draggable, destination, insideDestination, previousImpact, }: Args) => DragImpact | null;
+export default _default;

package/dist/types/state/move-in-direction/move-to-next-place/move-to-next-index/from-combine.d.ts

@@ -0,0 +1,11 @@
+import type { DroppableDimension, Combine, DraggableDimensionMap, DisplacementGroups, LiftEffect } from '../../../../types';
+type Args = {
+    isMovingForward: boolean;
+    destination: DroppableDimension;
+    displaced: DisplacementGroups;
+    draggables: DraggableDimensionMap;
+    combine: Combine;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ isMovingForward, destination, draggables, combine, afterCritical, }: Args) => number | null;
+export default _default;

package/dist/types/state/move-in-direction/move-to-next-place/move-to-next-index/from-reorder.d.ts

@@ -0,0 +1,9 @@
+import type { DraggableDimension, DraggableLocation } from '../../../../types';
+type Args = {
+    isMovingForward: boolean;
+    isInHomeList: boolean;
+    location: DraggableLocation;
+    insideDestination: DraggableDimension[];
+};
+declare const _default: ({ isMovingForward, isInHomeList, insideDestination, location, }: Args) => number | null;
+export default _default;

package/dist/types/state/move-in-direction/move-to-next-place/move-to-next-index/index.d.ts

@@ -0,0 +1,14 @@
+import type { DraggableDimension, DroppableDimension, DraggableDimensionMap, DragImpact, LiftEffect, Viewport } from '../../../../types';
+export type Args = {
+    isMovingForward: boolean;
+    isInHomeList: boolean;
+    draggable: DraggableDimension;
+    draggables: DraggableDimensionMap;
+    destination: DroppableDimension;
+    insideDestination: DraggableDimension[];
+    previousImpact: DragImpact;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+};
+declare const _default: ({ isMovingForward, isInHomeList, draggable, draggables, destination, insideDestination, previousImpact, viewport, afterCritical, }: Args) => DragImpact | null;
+export default _default;

package/dist/types/state/no-impact.d.ts

@@ -0,0 +1,6 @@
+import type { DisplacementGroups, DragImpact, DisplacedBy, LiftEffect } from '../types';
+export declare const noDisplacedBy: DisplacedBy;
+export declare const emptyGroups: DisplacementGroups;
+declare const noImpact: DragImpact;
+export default noImpact;
+export declare const noAfterCritical: LiftEffect;

package/dist/types/state/patch-dimension-map.d.ts

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

package/dist/types/state/patch-droppable-map.d.ts

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

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

@@ -0,0 +1,10 @@
+import { type Position } from 'css-box-model';
+export declare const origin: Position;
+export declare const add: (point1: Position, point2: Position) => Position;
+export declare const subtract: (point1: Position, point2: Position) => Position;
+export declare const isEqual: (point1: Position, point2: Position) => boolean;
+export declare const negate: (point: Position) => Position;
+export declare const patch: (line: "x" | "y", value: number, otherValue?: number) => Position;
+export declare const distance: (point1: Position, point2: Position) => number;
+export declare const closest: (target: Position, points: Position[]) => number;
+export declare const apply: (fn: (value: number) => number) => (point: Position) => Position;