@helpdice/draggable 0.0.0-stage → 0.0.2

package/dist/types/view/data-attributes.d.ts

@@ -0,0 +1,22 @@
+export declare const prefix: string;
+export declare const dragHandle: {
+    base: string;
+    draggableId: string;
+    contextId: string;
+};
+export declare const draggable: {
+    base: string;
+    contextId: string;
+    id: string;
+};
+export declare const droppable: {
+    base: string;
+    contextId: string;
+    id: string;
+};
+export declare const placeholder: {
+    contextId: string;
+};
+export declare const scrollContainer: {
+    contextId: string;
+};

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

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { Responders, Sensor } from "../../types";
+import type { SetAppCallbacks } from "./drag-drop-context-types";
+export type Props = Responders & {
+    contextId: string;
+    setCallbacks: SetAppCallbacks;
+    nonce?: string;
+    children: ReactNode;
+    sensors?: Sensor[] | null;
+    enableDefaultSensors?: boolean | null;
+    dragHandleUsageInstructions: string;
+};
+export default function App(props: Props): import("react").JSX.Element;

package/dist/types/view/drag-drop-context/check-doctype.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (doc: Document) => void;
+export default _default;

package/dist/types/view/drag-drop-context/check-react-version.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (peerDepValue: string, actualValue: string) => void;
+export default _default;

package/dist/types/view/drag-drop-context/drag-drop-context-types.d.ts

@@ -0,0 +1,5 @@
+export type AppCallbacks = {
+    isDragging: () => boolean;
+    tryAbort: () => void;
+};
+export type SetAppCallbacks = (callbacks: AppCallbacks) => void;

package/dist/types/view/drag-drop-context/drag-drop-context.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import type { Responders, Sensor } from '../../types';
+type Props = Responders & {
+    children: ReactNode;
+    dragHandleUsageInstructions?: string;
+    nonce?: string;
+    sensors?: Sensor[];
+    enableDefaultSensors?: boolean | null;
+};
+export declare function resetServerContext(): void;
+export default function DragDropContext(props: Props): import("react").JSX.Element;
+export {};

package/dist/types/view/drag-drop-context/error-boundary.d.ts

@@ -0,0 +1,20 @@
+import React, { type ReactNode } from 'react';
+import type { AppCallbacks } from './drag-drop-context-types';
+type Props = {
+    children: (setCallbacks: (callbacks: AppCallbacks) => void) => ReactNode;
+};
+type ErrorEvent = Event & {
+    error: Error | null;
+};
+export default class ErrorBoundary extends React.Component<Props> {
+    callbacks: AppCallbacks | null;
+    unbind: () => void;
+    componentDidMount(): void;
+    componentDidCatch(err: Error): void;
+    componentWillUnmount(): void;
+    onWindowError: (event: ErrorEvent) => void;
+    getCallbacks: () => AppCallbacks;
+    setCallbacks: (callbacks: AppCallbacks) => void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/types/view/drag-drop-context/index.d.ts

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

package/dist/types/view/drag-drop-context/use-startup-validation.d.ts

@@ -0,0 +1 @@
+export default function useStartupValidation(): void;

package/dist/types/view/drag-drop-context/use-unique-context-id.d.ts

@@ -0,0 +1,3 @@
+import type { ContextId } from "../../types";
+export declare function reset(): void;
+export default function useInstanceCount(): ContextId;

package/dist/types/view/draggable/connected-draggable.d.ts

@@ -0,0 +1,5 @@
+import type { OwnProps, Selector } from './draggable-types';
+import React from 'react';
+export declare const makeMapStateToProps: () => Selector;
+declare const _default: React.MemoExoticComponent<(props: OwnProps) => React.JSX.Element>;
+export default _default;

package/dist/types/view/draggable/draggable-api.d.ts

@@ -0,0 +1,3 @@
+import type { PublicOwnProps, PrivateOwnProps } from './draggable-types';
+export declare function PrivateDraggable(props: PrivateOwnProps): import("react").JSX.Element | null;
+export declare function PublicDraggable(props: PublicOwnProps): import("react").JSX.Element;

package/dist/types/view/draggable/draggable-types.d.ts

@@ -0,0 +1,106 @@
+import { type Position } from 'css-box-model';
+import { type ReactNode } from 'react';
+import type { DraggableId, DroppableId, DraggableDimension, State, MovementMode, ContextId, ElementId, DraggableRubric } from '../../types';
+import { dropAnimationFinished } from '../../state/action-creators';
+export type DraggingStyle = {
+    position: 'fixed';
+    top: number;
+    left: number;
+    boxSizing: 'border-box';
+    width: number;
+    height: number;
+    transition: string;
+    transform: string | null;
+    zIndex: number;
+    opacity: number | null;
+    pointerEvents: 'none';
+};
+export type NotDraggingStyle = {
+    transform: string | null;
+    transition: null | 'none';
+};
+export type DraggableStyle = DraggingStyle | NotDraggingStyle;
+export type ZIndexOptions = {
+    dragging: number;
+    dropAnimating: number;
+};
+export type DraggableProps = {
+    style: DraggableStyle | null;
+    'data-rbd-draggable-context-id': ContextId;
+    'data-rbd-draggable-id': DraggableId;
+    onTransitionEnd: ((event: TransitionEvent) => void) | null;
+};
+export type DragHandleProps = {
+    'data-rbd-drag-handle-draggable-id': DraggableId;
+    'data-rbd-drag-handle-context-id': ContextId;
+    role: string;
+    'aria-describedby': ElementId;
+    tabIndex: number;
+    draggable: boolean;
+    onDragStart: (event: DragEvent) => void;
+};
+export type Provided = {
+    draggableProps: DraggableProps;
+    dragHandleProps: DragHandleProps | null;
+    innerRef?: (arg0: HTMLElement) => void;
+};
+export type DropAnimation = {
+    duration: number;
+    curve: string;
+    moveTo: Position;
+    opacity: number | null;
+    scale: number | null;
+};
+export type StateSnapshot = {
+    isDragging: boolean;
+    isDropAnimating: boolean;
+    isClone: boolean;
+    dropAnimation: DropAnimation | null;
+    draggingOver: DroppableId | null;
+    combineWith: DraggableId | null;
+    combineTargetFor: DraggableId | null;
+    mode: MovementMode | null;
+};
+export type DispatchProps = {
+    dropAnimationFinished: typeof dropAnimationFinished;
+};
+export type DraggingMapProps = {
+    type: 'DRAGGING';
+    offset: Position;
+    mode: MovementMode;
+    dropping: DropAnimation | null;
+    draggingOver: DraggableId | null;
+    combineWith: DraggableId | null;
+    dimension: DraggableDimension;
+    forceShouldAnimate: boolean | null;
+    snapshot: StateSnapshot;
+};
+export type SecondaryMapProps = {
+    type: 'SECONDARY';
+    offset: Position;
+    combineTargetFor: DraggableId | null;
+    shouldAnimateDisplacement: boolean;
+    snapshot: StateSnapshot;
+};
+export type MappedProps = DraggingMapProps | SecondaryMapProps;
+export type MapProps = {
+    mapped: MappedProps;
+};
+export type ChildrenFn = (provided: Provided, snapshot: StateSnapshot, rubric: DraggableRubric) => ReactNode;
+export type PublicOwnProps = {
+    draggableId: DraggableId;
+    index: number;
+    children: ChildrenFn;
+    isDragDisabled?: boolean;
+    disableInteractiveElementBlocking?: boolean;
+    shouldRespectForcePress?: boolean;
+};
+export type PrivateOwnProps = PublicOwnProps & {
+    isClone: boolean;
+    isEnabled: boolean;
+    canDragInteractiveElements: boolean;
+    shouldRespectForcePress: boolean;
+};
+export type OwnProps = PrivateOwnProps & {};
+export type Props = MapProps & DispatchProps & OwnProps & {};
+export type Selector = (state: State, ownProps: OwnProps) => MapProps;

package/dist/types/view/draggable/draggable.d.ts

@@ -0,0 +1,2 @@
+import type { Props } from "./draggable-types";
+export default function Draggable(props: Props): import("react").ReactNode;

package/dist/types/view/draggable/get-style.d.ts

@@ -0,0 +1,3 @@
+import type { ZIndexOptions, DraggableStyle, MappedProps } from './draggable-types';
+export declare const zIndexOptions: ZIndexOptions;
+export default function getStyle(mapped: MappedProps): DraggableStyle;

package/dist/types/view/draggable/index.d.ts

@@ -0,0 +1 @@
+export { PublicDraggable as default } from './draggable-api';

package/dist/types/view/draggable/use-validation.d.ts

@@ -0,0 +1,4 @@
+import type { ContextId } from '../../types';
+import type { Props } from './draggable-types';
+export declare function useValidation(props: Props, contextId: ContextId, getRef: () => HTMLElement | null): void;
+export declare function useClonePropValidation(isClone: boolean): void;

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

@@ -0,0 +1,7 @@
+import type { OwnProps, Selector } from './droppable-types';
+export declare const makeMapStateToProps: () => Selector;
+declare const _default: import("react").MemoExoticComponent<{
+    (props: OwnProps): import("react").JSX.Element;
+    displayName: string;
+}>;
+export default _default;

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

@@ -0,0 +1,50 @@
+import { type ReactNode } from 'react';
+import type { DraggableId, DroppableId, TypeId, Direction, Placeholder, State, ContextId, DraggableRubric, DroppableMode } from '../../types';
+import type { ChildrenFn } from '../draggable/draggable-types';
+import { updateViewportMaxScroll } from '../../state/action-creators';
+export type DraggableChildrenFn = ChildrenFn;
+export type DroppableProps = {
+    'data-rbd-droppable-context-id': ContextId;
+    'data-rbd-droppable-id': DroppableId;
+};
+export type Provided = {
+    innerRef: (arg: HTMLElement | null) => void;
+    placeholder: ReactNode | null;
+    droppableProps: DroppableProps;
+};
+export type UseClone = {
+    dragging: DraggableRubric;
+    render: DraggableChildrenFn;
+};
+export type StateSnapshot = {
+    isDraggingOver: boolean;
+    draggingOverWith: DraggableId | null;
+    draggingFromThisWith: DraggableId | null;
+    isUsingPlaceholder: boolean;
+};
+export type MapProps = {
+    placeholder: Placeholder | null;
+    shouldAnimatePlaceholder: boolean;
+    snapshot: StateSnapshot;
+    useClone: UseClone | null;
+};
+export type DefaultProps = {
+    mode?: DroppableMode;
+    type?: TypeId;
+    isDropDisabled?: boolean;
+    isCombineEnabled?: boolean;
+    direction?: Direction;
+    renderClone?: DraggableChildrenFn | null;
+    ignoreContainerClipping?: boolean;
+    getContainerForClone: () => HTMLElement;
+};
+export type DispatchProps = {
+    updateViewportMaxScroll: typeof updateViewportMaxScroll;
+};
+export type OwnProps = DefaultProps & {
+    children: (Provided: any, StateSnapshot: any) => ReactNode;
+    droppableId: DroppableId;
+    renderClone: DraggableChildrenFn | null;
+};
+export type Props = MapProps & DispatchProps & OwnProps & {};
+export type Selector = (state: State, ownProps: OwnProps) => MapProps;

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

@@ -0,0 +1,2 @@
+import type { Props } from "./droppable-types";
+export default function Droppable(props: Props): import("react").JSX.Element;

package/dist/types/view/droppable/index.d.ts

@@ -0,0 +1 @@
+export { default } from './connected-droppable';

package/dist/types/view/droppable/use-validation.d.ts

@@ -0,0 +1,8 @@
+import type { Props } from './droppable-types';
+type Args = {
+    props: Props;
+    getDroppableRef: () => HTMLElement | null;
+    getPlaceholderRef: () => HTMLElement | null;
+};
+export default function useValidation(args: Args): void;
+export {};

package/dist/types/view/event-bindings/bind-events.d.ts

@@ -0,0 +1,2 @@
+import type { EventBinding, EventOptions } from './event-types';
+export default function bindEvents(el: HTMLElement | Window, bindings: EventBinding[], sharedOptions: EventOptions): () => void;

package/dist/types/view/event-bindings/event-types.d.ts

@@ -0,0 +1,10 @@
+export type EventOptions = {
+    passive?: boolean;
+    capture?: boolean;
+    once?: boolean;
+};
+export type EventBinding = {
+    eventName: string;
+    fn: Function;
+    options?: EventOptions;
+};

package/dist/types/view/get-body-element.d.ts

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

package/dist/types/view/get-border-box-center-position.d.ts

@@ -0,0 +1,3 @@
+import { type Position } from 'css-box-model';
+declare const _default: (el: HTMLElement) => Position;
+export default _default;

package/dist/types/view/get-document-element.d.ts

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

package/dist/types/view/get-elements/find-drag-handle.d.ts

@@ -0,0 +1,2 @@
+import type { DraggableId, ContextId } from '../../types';
+export default function findDragHandle(contextId: ContextId, draggableId: DraggableId): HTMLElement | null;

package/dist/types/view/get-elements/find-draggable.d.ts

@@ -0,0 +1,2 @@
+import type { DraggableId, ContextId } from '../../types';
+export default function findDraggable(contextId: ContextId, draggableId: DraggableId): HTMLElement | null;

package/dist/types/view/is-strict-equal.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (a: unknown, b: unknown) => boolean;
+export default _default;

package/dist/types/view/is-type-of-element/is-element.d.ts

@@ -0,0 +1 @@
+export default function isElement(el: Element | null): el is Element;

package/dist/types/view/is-type-of-element/is-html-element.d.ts

@@ -0,0 +1 @@
+export default function isHtmlElement(el: Element): el is HTMLElement;

package/dist/types/view/is-type-of-element/is-svg-element.d.ts

@@ -0,0 +1 @@
+export default function isSvgElement(el: Element): el is SVGElement;

package/dist/types/view/key-codes.d.ts

@@ -0,0 +1,12 @@
+export declare const tab: number;
+export declare const enter: number;
+export declare const escape: number;
+export declare const space: number;
+export declare const pageUp: number;
+export declare const pageDown: number;
+export declare const end: number;
+export declare const home: number;
+export declare const arrowLeft: number;
+export declare const arrowUp: number;
+export declare const arrowRight: number;
+export declare const arrowDown: number;

package/dist/types/view/placeholder/index.d.ts

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

package/dist/types/view/placeholder/placeholder-types.d.ts

@@ -0,0 +1,14 @@
+export type PlaceholderStyle = {
+    display: string;
+    boxSizing: 'border-box';
+    width: number;
+    height: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    marginLeft: number;
+    flexShrink: '0';
+    flexGrow: '0';
+    pointerEvents: 'none';
+    transition: string;
+};

package/dist/types/view/placeholder/placeholder.d.ts

@@ -0,0 +1,28 @@
+import React, { type ReactNode } from "react";
+import type { Placeholder as PlaceholderType, InOutAnimationMode, ContextId } from "../../types";
+export type PlaceholderStyle = {
+    display: string;
+    boxSizing: "border-box";
+    width: number;
+    height: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    marginLeft: number;
+    flexShrink: "0";
+    flexGrow: "0";
+    pointerEvents: "none";
+    transition: string | null;
+};
+export type Props = {
+    placeholder: PlaceholderType;
+    animate: InOutAnimationMode;
+    onClose: () => void;
+    innerRef: (value: HTMLElement | null) => void;
+    onTransitionEnd: () => void;
+    contextId: ContextId;
+};
+declare function Placeholder(props: Props): ReactNode;
+declare const _default: React.NamedExoticComponent<Props>;
+export default _default;
+export declare const WithoutMemo: typeof Placeholder;

package/dist/types/view/scroll-listener.d.ts

@@ -0,0 +1,12 @@
+import type { Position } from 'css-box-model';
+type OnWindowScroll = (newScroll: Position) => void;
+type Args = {
+    onWindowScroll: OnWindowScroll;
+};
+type Result = {
+    start: () => void;
+    stop: () => void;
+    isActive: () => boolean;
+};
+export default function getScrollListener({ onWindowScroll }: Args): Result;
+export {};

package/dist/types/view/throw-if-invalid-inner-ref.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ref: unknown | null) => void;
+export default _default;

package/dist/types/view/use-announcer/index.d.ts

@@ -0,0 +1 @@
+export { default } from './use-announcer';

package/dist/types/view/use-announcer/use-announcer.d.ts

@@ -0,0 +1,3 @@
+import type { Announce, ContextId } from "../../types";
+export declare const getId: (contextId: ContextId) => string;
+export default function useAnnouncer(contextId: ContextId): Announce;

package/dist/types/view/use-dev-setup-warning.d.ts

@@ -0,0 +1 @@
+export default function useDevSetupWarning(fn: () => void, inputs?: unknown[]): void;

package/dist/types/view/use-dev.d.ts

@@ -0,0 +1 @@
+export default function useDev(useHook: () => void): void;

package/dist/types/view/use-draggable-publisher/get-dimension.d.ts

@@ -0,0 +1,3 @@
+import { type Position } from 'css-box-model';
+import type { DraggableDescriptor, DraggableDimension } from '../../types';
+export default function getDimension(descriptor: DraggableDescriptor, el: HTMLElement, windowScroll?: Position): DraggableDimension;

package/dist/types/view/use-draggable-publisher/index.d.ts

@@ -0,0 +1 @@
+export { default } from './use-draggable-publisher';

package/dist/types/view/use-draggable-publisher/use-draggable-publisher.d.ts

@@ -0,0 +1,8 @@
+import type { DraggableDescriptor, DraggableOptions } from "../../types";
+import type { Registry } from "../../state/registry/registry-types";
+export type Args = {
+    descriptor: DraggableDescriptor;
+    getDraggableRef: () => HTMLElement | null;
+    registry: Registry;
+} & DraggableOptions;
+export default function useDraggablePublisher(args: Args): void;

package/dist/types/view/use-droppable-publisher/check-for-nested-scroll-container.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (scrollable: Element | null) => void;
+export default _default;

package/dist/types/view/use-droppable-publisher/get-closest-scrollable.d.ts

@@ -0,0 +1,2 @@
+declare const getClosestScrollable: (el: Element | null) => Element | null;
+export default getClosestScrollable;

package/dist/types/view/use-droppable-publisher/get-dimension.d.ts

@@ -0,0 +1,15 @@
+import { type Position } from 'css-box-model';
+import type { Env } from './get-env';
+import type { DroppableDimension, DroppableDescriptor, Direction } from '../../types';
+type Args = {
+    ref: HTMLElement;
+    descriptor: DroppableDescriptor;
+    env: Env;
+    windowScroll: Position;
+    direction?: Direction;
+    isDropDisabled?: boolean;
+    isCombineEnabled?: boolean;
+    shouldClipSubject: boolean;
+};
+declare const _default: ({ ref, descriptor, env, windowScroll, direction, isDropDisabled, isCombineEnabled, shouldClipSubject, }: Args) => DroppableDimension;
+export default _default;

package/dist/types/view/use-droppable-publisher/get-env.d.ts

@@ -0,0 +1,6 @@
+export type Env = {
+    closestScrollable: Element | null;
+    isFixedOnPage: boolean;
+};
+declare const _default: (start: Element) => Env;
+export default _default;

package/dist/types/view/use-droppable-publisher/get-listener-options.d.ts

@@ -0,0 +1,5 @@
+import type { ScrollOptions } from '../../types';
+declare const _default: (options: ScrollOptions) => {
+    passive: boolean;
+};
+export default _default;

package/dist/types/view/use-droppable-publisher/get-scroll.d.ts

@@ -0,0 +1,3 @@
+import type { Position } from 'css-box-model';
+declare const _default: (el: Element) => Position;
+export default _default;

package/dist/types/view/use-droppable-publisher/index.d.ts

@@ -0,0 +1 @@
+export { default } from './use-droppable-publisher';

package/dist/types/view/use-droppable-publisher/is-in-fixed-container.d.ts

@@ -0,0 +1,2 @@
+declare const find: (el: Element | null) => boolean;
+export default find;

package/dist/types/view/use-droppable-publisher/use-droppable-publisher.d.ts

@@ -0,0 +1,13 @@
+import type { DroppableId, TypeId, Direction, DroppableMode } from "../../types";
+type Props = {
+    droppableId: DroppableId;
+    type?: TypeId;
+    mode?: DroppableMode;
+    direction?: Direction;
+    isDropDisabled?: boolean;
+    isCombineEnabled?: boolean;
+    ignoreContainerClipping?: boolean;
+    getDroppableRef?: () => HTMLElement | null;
+};
+export default function useDroppablePublisher(args: Props): void;
+export {};

package/dist/types/view/use-focus-marshal/focus-marshal-types.d.ts

@@ -0,0 +1,9 @@
+import type { DraggableId } from '../../types';
+export type Unregister = () => void;
+export type Register = (id: DraggableId, focus: () => void) => Unregister;
+export type FocusMarshal = {
+    register: Register;
+    tryRecordFocus: (tryRecordFor: DraggableId) => void;
+    tryRestoreFocusRecorded: () => void;
+    tryShiftRecord: (previous: DraggableId, redirectTo: DraggableId) => void;
+};

package/dist/types/view/use-focus-marshal/index.d.ts

@@ -0,0 +1 @@
+export { default } from './use-focus-marshal';

package/dist/types/view/use-focus-marshal/use-focus-marshal.d.ts

@@ -0,0 +1,3 @@
+import type { ContextId } from "../../types";
+import type { FocusMarshal } from "./focus-marshal-types";
+export default function useFocusMarshal(contextId: ContextId): FocusMarshal;

package/dist/types/view/use-hidden-text-element/index.d.ts

@@ -0,0 +1 @@
+export { default } from './use-hidden-text-element';

package/dist/types/view/use-hidden-text-element/use-hidden-text-element.d.ts

@@ -0,0 +1,12 @@
+import type { ContextId, ElementId } from "../../types";
+type GetIdArgs = {
+    contextId: ContextId;
+    uniqueId: string;
+};
+export declare function getElementId({ contextId, uniqueId }: GetIdArgs): ElementId;
+type Args = {
+    contextId: ContextId;
+    text: string;
+};
+export default function useHiddenTextElement({ contextId, text, }: Args): ElementId;
+export {};

package/dist/types/view/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+export default useIsomorphicLayoutEffect;

package/dist/types/view/use-previous-ref.d.ts

@@ -0,0 +1 @@
+export default function usePrevious<T>(current: T): React.RefObject<T>;

package/dist/types/view/use-required-context.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from 'react';
+export default function useRequiredContext<T>(Context: Context<T | null>): T;

package/dist/types/view/use-sensor-marshal/closest.d.ts

@@ -0,0 +1 @@
+export default function closest(el: Element | null, selector: string): Element | null;

package/dist/types/view/use-sensor-marshal/find-closest-draggable-id-from-event.d.ts

@@ -0,0 +1,2 @@
+import type { ContextId, DraggableId } from '../../types';
+export default function tryGetClosestDraggableIdFromEvent(contextId: ContextId, event: Event): DraggableId | null;

package/dist/types/view/use-sensor-marshal/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './use-sensor-marshal';
+export { default as useMouseSensor } from './sensors/use-mouse-sensor';
+export { default as useTouchSensor } from './sensors/use-touch-sensor';
+export { default as useKeyboardSensor } from './sensors/use-keyboard-sensor';

package/dist/types/view/use-sensor-marshal/is-event-in-interactive-element.d.ts

@@ -0,0 +1,5 @@
+export type TagNameMap = {
+    [tagName: string]: true;
+};
+export declare const interactiveTagNames: TagNameMap;
+export default function isEventInInteractiveElement(draggable: Element, event: Event): boolean;

package/dist/types/view/use-sensor-marshal/lock.d.ts

@@ -0,0 +1,11 @@
+export type Lock = {
+    abandon: () => void;
+};
+export type LockAPI = {
+    isClaimed: () => boolean;
+    isActive: (lock: Lock) => boolean;
+    claim: (abandon: () => void) => Lock;
+    release: () => void;
+    tryAbandon: () => void;
+};
+export default function create(): LockAPI;

package/dist/types/view/use-sensor-marshal/sensors/use-keyboard-sensor.d.ts

@@ -0,0 +1,2 @@
+import type { SensorAPI } from "../../../types";
+export default function useKeyboardSensor(api: SensorAPI): void;