@helpdice/draggable 0.0.0-stage → 0.0.2

package/dist/types/state/post-reducer/when-moving/refresh-snap.d.ts

@@ -0,0 +1,8 @@
+import type { StateWhenUpdatesAllowed, DimensionMap, Viewport } from '../../../types';
+type Args = {
+    state: StateWhenUpdatesAllowed;
+    dimensions?: DimensionMap;
+    viewport?: Viewport;
+};
+declare const _default: ({ state, dimensions: forcedDimensions, viewport: forcedViewport, }: Args) => StateWhenUpdatesAllowed;
+export default _default;

package/dist/types/state/post-reducer/when-moving/update.d.ts

@@ -0,0 +1,12 @@
+import type { Position } from 'css-box-model';
+import type { DragImpact, Viewport, DimensionMap, StateWhenUpdatesAllowed } from '../../../types';
+type Args = {
+    state: StateWhenUpdatesAllowed;
+    clientSelection?: Position;
+    dimensions?: DimensionMap;
+    viewport?: Viewport;
+    impact?: DragImpact | null;
+    scrollJumpRequest?: Position | null;
+};
+declare const _default: ({ state, clientSelection: forcedClientSelection, dimensions: forcedDimensions, viewport: forcedViewport, impact: forcedImpact, scrollJumpRequest, }: Args) => StateWhenUpdatesAllowed;
+export default _default;

package/dist/types/state/publish-while-dragging-in-virtual/adjust-additions-for-scroll-changes.d.ts

@@ -0,0 +1,8 @@
+import type { Viewport, DraggableDimension, DroppableDimensionMap } from '../../types';
+type Args = {
+    additions: DraggableDimension[];
+    updatedDroppables: DroppableDimensionMap;
+    viewport: Viewport;
+};
+declare const _default: ({ additions, updatedDroppables, viewport, }: Args) => DraggableDimension[];
+export default _default;

package/dist/types/state/publish-while-dragging-in-virtual/index.d.ts

@@ -0,0 +1,7 @@
+import type { DraggingState, CollectingState, DropPendingState, Published } from '../../types';
+type Args = {
+    state: CollectingState | DropPendingState;
+    published: Published;
+};
+declare const _default: ({ state, published, }: Args) => DraggingState | DropPendingState;
+export default _default;

package/dist/types/state/publish-while-dragging-in-virtual/offset-draggable.d.ts

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

package/dist/types/state/recompute-placeholders.d.ts

@@ -0,0 +1,10 @@
+import type { DraggableDimensionMap, DroppableDimensionMap, DraggableDimension, DragImpact } from '../types';
+type Args = {
+    draggable: DraggableDimension;
+    draggables: DraggableDimensionMap;
+    droppables: DroppableDimensionMap;
+    impact: DragImpact;
+    previousImpact: DragImpact;
+};
+declare const _default: ({ draggable, draggables, droppables, previousImpact, impact, }: Args) => DroppableDimensionMap;
+export default _default;

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

@@ -0,0 +1,2 @@
+import type { Rect, Position } from 'css-box-model';
+export declare const offsetRectByPosition: (rect: Rect, point: Position) => Rect;

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

@@ -0,0 +1,5 @@
+import type { State, DraggingState, CollectingState, DropPendingState } from '../types';
+import type { Action } from './store-types';
+export declare function isDragging(state: State): state is DraggingState | CollectingState | DropPendingState;
+declare const _default: (state: State | undefined, action: Action) => State;
+export default _default;

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

@@ -0,0 +1,2 @@
+import type { Registry } from './registry-types';
+export default function createRegistry(): Registry;

package/dist/types/state/registry/registry-types.d.ts

@@ -0,0 +1,62 @@
+import type { Position } from 'css-box-model';
+import type { Id, DraggableId, DraggableDescriptor, DraggableOptions, DraggableDimension, DroppableId, ScrollOptions, DroppableDescriptor, DroppableDimension, TypeId } from '../../types';
+export type GetDraggableDimensionFn = (windowScroll: Position) => DraggableDimension;
+export type DraggableEntry = {
+    uniqueId: Id;
+    descriptor: DraggableDescriptor;
+    options: DraggableOptions;
+    getDimension: GetDraggableDimensionFn;
+};
+export type DraggableAPI = {
+    register: (entry: DraggableEntry) => void;
+    update: (entry: DraggableEntry, last: DraggableEntry) => void;
+    unregister: (entry: DraggableEntry) => void;
+    exists: (id: DraggableId) => boolean;
+    getById: (id: DraggableId) => DraggableEntry;
+    findById: (id: DraggableId) => DraggableEntry | null;
+    getAllByType: (type: TypeId) => DraggableEntry[];
+};
+export type GetDroppableDimensionFn = (windowScroll: Position, options: ScrollOptions) => DroppableDimension;
+export type RecollectDroppableOptions = {
+    withoutPlaceholder: boolean;
+};
+export type DroppableCallbacks = {
+    getDimensionAndWatchScroll: GetDroppableDimensionFn;
+    getScrollWhileDragging: () => Position;
+    scroll: (change: Position) => void;
+    dragStopped: () => void;
+};
+export type DroppableEntry = {
+    uniqueId: Id;
+    descriptor: DroppableDescriptor;
+    callbacks: DroppableCallbacks;
+};
+export type DraggableEntryMap = {
+    [id: DraggableId]: DraggableEntry;
+};
+export type DroppableEntryMap = {
+    [id: DroppableId]: DroppableEntry;
+};
+export type DroppableAPI = {
+    register: (entry: DroppableEntry) => void;
+    unregister: (entry: DroppableEntry) => void;
+    exists: (id: DraggableId) => boolean;
+    getById: (id: DroppableId) => DroppableEntry;
+    findById: (id: DroppableId) => DroppableEntry | null;
+    getAllByType: (type: TypeId) => DroppableEntry[];
+};
+export type RegistryEvent = {
+    type: 'ADDITION';
+    value: DraggableEntry;
+} | {
+    type: 'REMOVAL';
+    value: DraggableEntry;
+};
+export type Subscriber = (event: RegistryEvent) => void;
+export type Unsubscribe = () => void;
+export type Registry = {
+    draggable: DraggableAPI;
+    droppable: DroppableAPI;
+    subscribe: (cb: Subscriber) => Unsubscribe;
+    clean: () => void;
+};

package/dist/types/state/registry/use-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from "./registry-types";
+export default function useRegistry(): Registry;

package/dist/types/state/remove-draggable-from-list.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+import type { Spacing, Position } from 'css-box-model';
+export declare const isEqual: (first: Spacing, second: Spacing) => boolean;
+export declare const offsetByPosition: (spacing: Spacing, point: Position) => Spacing;
+export declare const expandByPosition: (spacing: Spacing, position: Position) => Spacing;
+export declare const getCorners: (spacing: Spacing) => Position[];
+export declare const noSpacing: Spacing;

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

@@ -0,0 +1,10 @@
+import type { Store as ReduxStore, Dispatch as ReduxDispatch, Middleware as ReduxMiddleware, MiddlewareAPI as ReduxMiddlewareAPI } from 'redux';
+import type { Action as ActionCreators } from './action-creators';
+import type { State as ReduxState } from '../types';
+export type Action = ActionCreators;
+export type State = ReduxState;
+export type Dispatch = ReduxDispatch<Action>;
+export type LazyDispatch = ReduxDispatch<Action>;
+export type Store = ReduxStore<State, Action, Dispatch>;
+export type Middleware = ReduxMiddleware<State, Action, Dispatch>;
+export type MiddlewareStore = ReduxMiddlewareAPI<Dispatch, State>;

package/dist/types/state/update-displacement-visibility/recompute.d.ts

@@ -0,0 +1,10 @@
+import type { DroppableDimension, DraggableDimensionMap, DragImpact, Viewport } from '../../types';
+type RecomputeArgs = {
+    impact: DragImpact;
+    draggables: DraggableDimensionMap;
+    destination: DroppableDimension;
+    viewport: Viewport;
+    forceShouldAnimate?: boolean;
+};
+declare const _default: ({ impact, viewport, draggables, destination, forceShouldAnimate, }: RecomputeArgs) => DragImpact;
+export default _default;

package/dist/types/state/update-displacement-visibility/speculatively-increase.d.ts

@@ -0,0 +1,11 @@
+import type { Position } from 'css-box-model';
+import type { DroppableDimension, DraggableDimensionMap, DragImpact, Viewport } from '../../types';
+type SpeculativeArgs = {
+    impact: DragImpact;
+    destination: DroppableDimension;
+    viewport: Viewport;
+    draggables: DraggableDimensionMap;
+    maxScrollChange: Position;
+};
+declare const _default: ({ impact, viewport, destination, draggables, maxScrollChange, }: SpeculativeArgs) => DragImpact;
+export default _default;

package/dist/types/state/visibility/is-partially-visible-through-frame.d.ts

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

package/dist/types/state/visibility/is-position-in-frame.d.ts

@@ -0,0 +1,2 @@
+import { type Position, type Spacing } from 'css-box-model';
+export default function isPositionInFrame(frame: Spacing): (point: Position) => boolean;

package/dist/types/state/visibility/is-totally-visible-through-frame-on-axis.d.ts

@@ -0,0 +1,4 @@
+import { type Spacing } from 'css-box-model';
+import type { Axis } from '../../types';
+declare const _default: (axis: Axis) => (frame: Spacing) => (subject: Spacing) => boolean;
+export default _default;

package/dist/types/state/visibility/is-totally-visible-through-frame.d.ts

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

package/dist/types/state/visibility/is-visible.d.ts

@@ -0,0 +1,13 @@
+import { type Spacing, type Rect } from 'css-box-model';
+import type { DroppableDimension } from '../../types';
+export type Args = {
+    target: Spacing;
+    destination: DroppableDimension;
+    viewport: Rect;
+    withDroppableDisplacement: boolean;
+    shouldCheckDroppable?: boolean;
+    shouldCheckViewport?: boolean;
+};
+export declare const isPartiallyVisible: (args: Args) => boolean;
+export declare const isTotallyVisible: (args: Args) => boolean;
+export declare const isTotallyVisibleOnAxis: (args: Args) => boolean;

package/dist/types/state/with-scroll-change/with-all-displacement.d.ts

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

package/dist/types/state/with-scroll-change/with-droppable-displacement.d.ts

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

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

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

package/dist/types/state/with-scroll-change/with-viewport-displacement.d.ts

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

package/dist/types/types.d.ts

@@ -0,0 +1,323 @@
+import type { BoxModel, Rect, Position } from 'css-box-model';
+export type Id = string;
+export type DraggableId = Id;
+export type DroppableId = Id;
+export type TypeId = Id;
+export type ContextId = Id;
+export type ElementId = Id;
+export type AnimationFrameID = number;
+export type TimeoutID = ReturnType<typeof setTimeout>;
+export type DroppableMode = 'standard' | 'virtual';
+export type DroppableDescriptor = {
+    id: DroppableId;
+    type: TypeId;
+    mode: DroppableMode;
+};
+export type DraggableDescriptor = {
+    id: DraggableId;
+    index: number;
+    droppableId: DroppableId;
+    type: TypeId;
+};
+export type DraggableOptions = {
+    canDragInteractiveElements: boolean;
+    shouldRespectForcePress: boolean;
+    isEnabled: boolean;
+};
+export type Direction = 'horizontal' | 'vertical';
+export type VerticalAxis = {
+    direction: 'vertical';
+    line: 'y';
+    start: 'top';
+    end: 'bottom';
+    size: 'height';
+    crossAxisLine: 'x';
+    crossAxisStart: 'left';
+    crossAxisEnd: 'right';
+    crossAxisSize: 'width';
+};
+export type HorizontalAxis = {
+    direction: 'horizontal';
+    line: 'x';
+    start: 'left';
+    end: 'right';
+    size: 'width';
+    crossAxisLine: 'y';
+    crossAxisStart: 'top';
+    crossAxisEnd: 'bottom';
+    crossAxisSize: 'height';
+};
+export type Axis = VerticalAxis | HorizontalAxis;
+export type ScrollSize = {
+    scrollHeight: number;
+    scrollWidth: number;
+};
+export type ScrollDetails = {
+    initial: Position;
+    current: Position;
+    max: Position;
+    diff: {
+        value: Position;
+        displacement: Position;
+    };
+};
+export type Placeholder = {
+    client: BoxModel;
+    tagName: string;
+    display: string;
+};
+export type DraggableDimension = {
+    descriptor: DraggableDescriptor;
+    placeholder: Placeholder;
+    client: BoxModel;
+    page: BoxModel;
+    displaceBy: Position;
+};
+export type Scrollable = {
+    pageMarginBox: Rect;
+    frameClient: BoxModel;
+    scrollSize: ScrollSize;
+    shouldClipSubject: boolean;
+    scroll: ScrollDetails;
+};
+export type PlaceholderInSubject = {
+    increasedBy: Position | null;
+    placeholderSize: Position;
+    oldFrameMaxScroll: Position | null;
+};
+export type DroppableSubject = {
+    page: BoxModel;
+    withPlaceholder: PlaceholderInSubject | null;
+    active: Rect | null;
+};
+export type DroppableDimension = {
+    descriptor: DroppableDescriptor;
+    axis: Axis;
+    isEnabled: boolean;
+    isCombineEnabled?: boolean;
+    client: BoxModel;
+    isFixedOnPage: boolean;
+    page: BoxModel;
+    frame: Scrollable | null;
+    subject: DroppableSubject;
+};
+export type DraggableLocation = {
+    droppableId: DroppableId;
+    index: number;
+};
+export type DraggableIdMap = {
+    [id: DraggableId]: true;
+};
+export type DroppableIdMap = {
+    [id: DroppableId]: true;
+};
+export type DraggableDimensionMap = {
+    [key: DraggableId]: DraggableDimension;
+};
+export type DroppableDimensionMap = Record<DroppableId, DroppableDimension>;
+export type Displacement = {
+    draggableId: DraggableId;
+    shouldAnimate: boolean;
+};
+export type DisplacementMap = {
+    [key: DraggableId]: Displacement;
+};
+export type DisplacedBy = {
+    value: number;
+    point: Position;
+};
+export type Combine = {
+    draggableId: DraggableId;
+    droppableId: DroppableId;
+};
+export type DisplacementGroups = {
+    all: DraggableId[];
+    visible: DisplacementMap;
+    invisible: DraggableIdMap;
+};
+export type ReorderImpact = {
+    type: 'REORDER';
+    destination: DraggableLocation;
+};
+export type CombineImpact = {
+    type: 'COMBINE';
+    combine: Combine;
+};
+export type ImpactLocation = ReorderImpact | CombineImpact;
+export type Displaced = {
+    forwards: DisplacementGroups;
+    backwards: DisplacementGroups;
+};
+export type DragImpact = {
+    displaced: DisplacementGroups;
+    displacedBy: DisplacedBy;
+    at: ImpactLocation | null;
+};
+export type ClientPositions = {
+    selection: Position;
+    borderBoxCenter: Position;
+    offset: Position;
+};
+export type PagePositions = {
+    selection: Position;
+    borderBoxCenter: Position;
+    offset: Position;
+};
+export type MovementMode = 'FLUID' | 'SNAP';
+export type DragPositions = {
+    client: ClientPositions;
+    page: PagePositions;
+};
+export type DraggableRubric = {
+    draggableId: DraggableId;
+    type: TypeId;
+    source: DraggableLocation;
+};
+export type BeforeCapture = {
+    draggableId: DraggableId;
+    mode: MovementMode;
+};
+export type DragStart = DraggableRubric & {
+    mode: MovementMode;
+};
+export type DragUpdate = DragStart & {
+    destination: DraggableLocation | null;
+    combine: Combine | null;
+};
+export type DropReason = 'DROP' | 'CANCEL';
+export type DropResult = DragUpdate & {
+    reason: DropReason;
+};
+export type ScrollOptions = {
+    shouldPublishImmediately: boolean;
+};
+export type LiftRequest = {
+    draggableId: DraggableId;
+    scrollOptions: ScrollOptions;
+};
+export type Critical = {
+    draggable: DraggableDescriptor;
+    droppable: DroppableDescriptor;
+};
+export type Viewport = {
+    frame: Rect;
+    scroll: ScrollDetails;
+};
+export type LiftEffect = {
+    inVirtualList: boolean;
+    effected: DraggableIdMap;
+    displacedBy: DisplacedBy;
+};
+export type DimensionMap = {
+    draggables: DraggableDimensionMap;
+    droppables: DroppableDimensionMap;
+};
+export type DroppablePublish = {
+    droppableId: DroppableId;
+    scroll: Position;
+};
+export type Published = {
+    additions: DraggableDimension[];
+    removals: DraggableId[];
+    modified: DroppablePublish[];
+};
+export type CompletedDrag = {
+    critical: Critical;
+    result: DropResult;
+    impact: DragImpact;
+    afterCritical: LiftEffect;
+};
+export type IdleState = {
+    phase: 'IDLE';
+    completed: CompletedDrag | null;
+    shouldFlush: boolean;
+};
+export type DraggingState = {
+    phase: 'DRAGGING';
+    isDragging: true;
+    critical: Critical;
+    movementMode: MovementMode;
+    dimensions: DimensionMap;
+    initial: DragPositions;
+    current: DragPositions;
+    impact: DragImpact;
+    viewport: Viewport;
+    afterCritical: LiftEffect;
+    onLiftImpact: DragImpact;
+    isWindowScrollAllowed: boolean;
+    scrollJumpRequest: Position | null;
+    forceShouldAnimate: boolean | null;
+};
+export type CollectingState = Omit<DraggingState, 'phase'> & {
+    phase: 'COLLECTING';
+};
+export type DropPendingState = Omit<DraggingState, 'phase'> & {
+    phase: 'DROP_PENDING';
+    isWaiting: boolean;
+    reason: DropReason;
+};
+export type DropAnimatingState = {
+    phase: 'DROP_ANIMATING';
+    completed: CompletedDrag;
+    newHomeClientOffset: Position;
+    dropDuration: number;
+    dimensions: DimensionMap;
+};
+export type State = IdleState | DraggingState | CollectingState | DropPendingState | DropAnimatingState;
+export type StateWhenUpdatesAllowed = DraggingState | CollectingState;
+export type Announce = (message: string) => void;
+export type InOutAnimationMode = 'none' | 'open' | 'close';
+export type ResponderProvided = {
+    announce: Announce;
+};
+export type OnBeforeCaptureResponder = (before: BeforeCapture) => unknown;
+export type OnBeforeDragStartResponder = (start: DragStart) => unknown;
+export type OnDragStartResponder = (start: DragStart, provided: ResponderProvided) => unknown;
+export type OnDragUpdateResponder = (update: DragUpdate, provided: ResponderProvided) => unknown;
+export type OnDragEndResponder = (result: DropResult, provided: ResponderProvided) => unknown;
+export type Responders = {
+    onBeforeCapture?: OnBeforeCaptureResponder | null;
+    onBeforeDragStart?: OnBeforeDragStartResponder | null;
+    onDragStart?: OnDragStartResponder | null;
+    onDragUpdate?: OnDragUpdateResponder | null;
+    onDragEnd: OnDragEndResponder;
+};
+export type StopDragOptions = {
+    shouldBlockNextClick: boolean;
+};
+type DragActions = {
+    drop: (args?: StopDragOptions) => void;
+    cancel?: (args?: StopDragOptions) => void;
+    isActive: () => boolean;
+    shouldRespectForcePress: () => boolean;
+};
+export type FluidDragActions = DragActions & {
+    move: (clientSelection: Position) => void;
+};
+export type SnapDragActions = DragActions & {
+    moveUp?: () => void;
+    moveDown?: () => void;
+    moveRight?: () => void;
+    moveLeft?: () => void;
+};
+export type PreDragActions = {
+    isActive: () => boolean;
+    shouldRespectForcePress: () => boolean;
+    fluidLift: (clientSelection: Position) => FluidDragActions;
+    snapLift: () => SnapDragActions;
+    abort: () => void;
+};
+export type TryGetLockOptions = {
+    sourceEvent?: Event;
+};
+export type TryGetLock = (draggableId: DraggableId, forceStop?: () => void, options?: TryGetLockOptions) => PreDragActions | null;
+export type SensorAPI = {
+    tryGetLock: TryGetLock;
+    canGetLock: (id: DraggableId) => boolean;
+    isLockClaimed: () => boolean;
+    tryReleaseLock: () => void;
+    findClosestDraggableId: (event: Event) => DraggableId | null;
+    findOptionsForDraggable: (id: DraggableId) => DraggableOptions | null;
+};
+export type Sensor = (api: SensorAPI) => void;
+export {};

package/dist/types/view/animate-in-out/animate-in-out.d.ts

@@ -0,0 +1,24 @@
+import React, { type ReactNode } from 'react';
+import type { InOutAnimationMode } from '../../types';
+export type AnimateProvided = {
+    onClose: () => void;
+    animate: InOutAnimationMode;
+    data: unknown;
+};
+type Props = {
+    on: unknown;
+    shouldAnimate: boolean;
+    children: (provided: AnimateProvided) => ReactNode;
+};
+type State = {
+    data: unknown;
+    isVisible: boolean;
+    animate: InOutAnimationMode;
+};
+export default class AnimateInOut extends React.PureComponent<Props, State> {
+    state: State;
+    static getDerivedStateFromProps(props: Props, state: State): State;
+    onClose: () => void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/types/view/animate-in-out/index.d.ts

@@ -0,0 +1 @@
+export { default } from './animate-in-out';

package/dist/types/view/check-is-valid-inner-ref.d.ts

@@ -0,0 +1 @@
+export default function checkIsValidInnerRef(el: HTMLElement | null): void;

package/dist/types/view/context/app-context.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DraggableId, ContextId, ElementId } from '../../types';
+import type { DimensionMarshal } from '../../state/dimension-marshal/dimension-marshal-types';
+import type { FocusMarshal } from '../use-focus-marshal/focus-marshal-types';
+import type { Registry } from '../../state/registry/registry-types';
+export type AppContextValue = {
+    focus: FocusMarshal;
+    contextId: ContextId;
+    canLift: (id: DraggableId) => boolean;
+    isMovementAllowed: () => boolean;
+    dragHandleUsageInstructionsId: ElementId;
+    marshal: DimensionMarshal;
+    registry: Registry;
+};
+declare const _default: React.Context<AppContextValue | null>;
+export default _default;

package/dist/types/view/context/droppable-context.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { DraggableId, DroppableId, TypeId } from '../../types';
+export type DroppableContextValue = {
+    isUsingCloneFor?: DraggableId | null;
+    droppableId: DroppableId;
+    type?: TypeId;
+};
+declare const _default: React.Context<DroppableContextValue | null>;
+export default _default;

package/dist/types/view/context/hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const useAppDispatch: import("react-redux").UseDispatch<import("redux").Dispatch<import("../../state/action-creators").Action>>;
+export declare const useAppSelector: import("react-redux").UseSelector<unknown>;
+export declare const useAppStore: import("react-redux").UseStore<import("redux").Store<import("../../types").State, import("../../state/action-creators").Action, unknown>>;

package/dist/types/view/context/store-context.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ReactReduxContextValue } from 'react-redux';
+declare const _default: React.Context<ReactReduxContextValue<import("../../types").State, import("../../state/action-creators").Action> | null>;
+export default _default;