.-.-.-.-.-

useDragLayer.d.ts000064400000000370151701363120007724 0ustar00import { DragLayerMonitor } from '../interfaces';
/**
 * useDragLayer Hook
 * @param collector The property collector
 */
export declare function useDragLayer<CollectedProps>(collect: (monitor: DragLayerMonitor) => CollectedProps): CollectedProps;
useDragDropManager.d.ts000064400000000252151701363120011046 0ustar00import { DragDropManager } from 'dnd-core';
/**
 * A hook to retrieve the DragDropManager from Context
 */
export declare function useDragDropManager(): DragDropManager;
useDrag.d.ts000064400000000641151701363120006730 0ustar00import { DragSourceHookSpec, DragObjectWithType, ConnectDragSource, ConnectDragPreview } from '../interfaces';
/**
 * useDragSource hook
 * @param sourceSpec The drag source specification *
 */
export declare function useDrag<DragObject extends DragObjectWithType, DropResult, CollectedProps>(spec: DragSourceHookSpec<DragObject, DropResult, CollectedProps>): [CollectedProps, ConnectDragSource, ConnectDragPreview];
useDrop.js000064400000002044151701363120006522 0ustar00import { useRef, useMemo } from 'react';
import { invariant } from '@react-dnd/invariant';
import { useMonitorOutput } from './internal/useMonitorOutput';
import { useIsomorphicLayoutEffect } from './internal/useIsomorphicLayoutEffect';
import { useDropHandler, useDropTargetMonitor } from './internal/drop';
/**
 * useDropTarget Hook
 * @param spec The drop target specification
 */
export function useDrop(spec) {
    const specRef = useRef(spec);
    specRef.current = spec;
    invariant(spec.accept != null, 'accept must be defined');
    const [monitor, connector] = useDropTargetMonitor();
    useDropHandler(specRef, monitor, connector);
    const result = useMonitorOutput(monitor, specRef.current.collect || (() => ({})), () => connector.reconnect());
    const connectDropTarget = useMemo(() => connector.hooks.dropTarget(), [
        connector,
    ]);
    useIsomorphicLayoutEffect(() => {
        connector.dropTargetOptions = spec.options || null;
        connector.reconnect();
    }, [spec.options]);
    return [result, connectDropTarget];
}
useDrop.d.ts000064400000000561151701363120006760 0ustar00import { DropTargetHookSpec, ConnectDropTarget, DragObjectWithType } from '../interfaces';
/**
 * useDropTarget Hook
 * @param spec The drop target specification
 */
export declare function useDrop<DragObject extends DragObjectWithType, DropResult, CollectedProps>(spec: DropTargetHookSpec<DragObject, DropResult, CollectedProps>): [CollectedProps, ConnectDropTarget];
internal/drag.js000064400000004704151701363120007637 0ustar00import { useMemo } from 'react';
import { invariant } from '@react-dnd/invariant';
import { registerSource } from '../../common/registration';
import { useDragDropManager } from '../useDragDropManager';
import { DragSourceMonitorImpl } from '../../common/DragSourceMonitorImpl';
import { SourceConnector } from '../../common/SourceConnector';
import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
export function useDragSourceMonitor() {
    const manager = useDragDropManager();
    const monitor = useMemo(() => new DragSourceMonitorImpl(manager), [manager]);
    const connector = useMemo(() => new SourceConnector(manager.getBackend()), [
        manager,
    ]);
    return [monitor, connector];
}
export function useDragHandler(spec, monitor, connector) {
    const manager = useDragDropManager();
    const handler = useMemo(() => {
        return {
            beginDrag() {
                const { begin, item } = spec.current;
                if (begin) {
                    const beginResult = begin(monitor);
                    invariant(beginResult == null || typeof beginResult === 'object', 'dragSpec.begin() must either return an object, undefined, or null');
                    return beginResult || item || {};
                }
                return item || {};
            },
            canDrag() {
                if (typeof spec.current.canDrag === 'boolean') {
                    return spec.current.canDrag;
                }
                else if (typeof spec.current.canDrag === 'function') {
                    return spec.current.canDrag(monitor);
                }
                else {
                    return true;
                }
            },
            isDragging(globalMonitor, target) {
                const { isDragging } = spec.current;
                return isDragging
                    ? isDragging(monitor)
                    : target === globalMonitor.getSourceId();
            },
            endDrag() {
                const { end } = spec.current;
                if (end) {
                    end(monitor.getItem(), monitor);
                }
                connector.reconnect();
            },
        };
    }, []);
    useIsomorphicLayoutEffect(function registerHandler() {
        const [handlerId, unregister] = registerSource(spec.current.item.type, handler, manager);
        monitor.receiveHandlerId(handlerId);
        connector.receiveHandlerId(handlerId);
        return unregister;
    }, []);
}
internal/drag.d.ts000064400000001011151701363120010057 0ustar00import { MutableRefObject } from 'react';
import { DragSourceHookSpec, DragObjectWithType, DragSourceMonitor } from '../../interfaces';
import { SourceConnector } from '../../common/SourceConnector';
export declare function useDragSourceMonitor(): [DragSourceMonitor, SourceConnector];
export declare function useDragHandler<DragObject extends DragObjectWithType, DropResult, CustomProps>(spec: MutableRefObject<DragSourceHookSpec<DragObject, DropResult, CustomProps>>, monitor: DragSourceMonitor, connector: any): void;
internal/useIsomorphicLayoutEffect.d.ts000064400000000145151701363120014315 0ustar00import { useEffect } from 'react';
export declare const useIsomorphicLayoutEffect: typeof useEffect;
internal/useCollector.d.ts000064400000000436151701363120011617 0ustar00/**
 *
 * @param monitor The monitor to collect state from
 * @param collect The collecting function
 * @param onUpdate A method to invoke when updates occur
 */
export declare function useCollector<T, S>(monitor: T, collect: (monitor: T) => S, onUpdate?: () => void): [S, () => void];
internal/useMonitorOutput.d.ts000064400000000422151701363120012534 0ustar00import { HandlerManager, MonitorEventEmitter } from '../../interfaces';
export declare function useMonitorOutput<Monitor extends HandlerManager, Collected>(monitor: Monitor & MonitorEventEmitter, collect: (monitor: Monitor) => Collected, onCollect?: () => void): Collected;
internal/useIsomorphicLayoutEffect.js000064400000000322151701363120014056 0ustar00import { useLayoutEffect, useEffect } from 'react';
// suppress the useLayoutEffect warning on server side.
export const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
internal/useMonitorOutput.js000064400000001176151701363120012307 0ustar00import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
import { useCollector } from './useCollector';
export function useMonitorOutput(monitor, collect, onCollect) {
    const [collected, updateCollected] = useCollector(monitor, collect, onCollect);
    useIsomorphicLayoutEffect(function subscribeToMonitorStateChange() {
        const handlerId = monitor.getHandlerId();
        if (handlerId == null) {
            return undefined;
        }
        return monitor.subscribeToStateChange(updateCollected, {
            handlerIds: [handlerId],
        });
    }, [monitor, updateCollected]);
    return collected;
}
internal/drop.d.ts000064400000001011151701363120010106 0ustar00import { DragObjectWithType, DropTargetMonitor, DropTargetHookSpec } from '../../interfaces';
import { MutableRefObject } from 'react';
import { TargetConnector } from '../../common/TargetConnector';
export declare function useDropTargetMonitor(): [DropTargetMonitor, TargetConnector];
export declare function useDropHandler<DragObject extends DragObjectWithType, DropResult, CustomProps>(spec: MutableRefObject<DropTargetHookSpec<DragObject, DropResult, CustomProps>>, monitor: DropTargetMonitor, connector: any): void;
internal/drop.js000064400000003250151701363120007661 0ustar00import { useMemo } from 'react';
import { registerTarget } from '../../common/registration';
import { useDragDropManager } from '../useDragDropManager';
import { TargetConnector } from '../../common/TargetConnector';
import { DropTargetMonitorImpl } from '../../common/DropTargetMonitorImpl';
import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
export function useDropTargetMonitor() {
    const manager = useDragDropManager();
    const monitor = useMemo(() => new DropTargetMonitorImpl(manager), [manager]);
    const connector = useMemo(() => new TargetConnector(manager.getBackend()), [
        manager,
    ]);
    return [monitor, connector];
}
export function useDropHandler(spec, monitor, connector) {
    const manager = useDragDropManager();
    const handler = useMemo(() => {
        return {
            canDrop() {
                const { canDrop } = spec.current;
                return canDrop ? canDrop(monitor.getItem(), monitor) : true;
            },
            hover() {
                const { hover } = spec.current;
                if (hover) {
                    hover(monitor.getItem(), monitor);
                }
            },
            drop() {
                const { drop } = spec.current;
                if (drop) {
                    return drop(monitor.getItem(), monitor);
                }
            },
        };
    }, [monitor]);
    useIsomorphicLayoutEffect(function registerHandler() {
        const [handlerId, unregister] = registerTarget(spec.current.accept, handler, manager);
        monitor.receiveHandlerId(handlerId);
        connector.receiveHandlerId(handlerId);
        return unregister;
    }, [monitor, connector]);
}
internal/useCollector.js000064400000001721151701363120011361 0ustar00import { shallowEqual } from '@react-dnd/shallowequal';
import { useState, useCallback } from 'react';
import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
/**
 *
 * @param monitor The monitor to collect state from
 * @param collect The collecting function
 * @param onUpdate A method to invoke when updates occur
 */
export function useCollector(monitor, collect, onUpdate) {
    const [collected, setCollected] = useState(() => collect(monitor));
    const updateCollected = useCallback(() => {
        const nextValue = collect(monitor);
        if (!shallowEqual(collected, nextValue)) {
            setCollected(nextValue);
            if (onUpdate) {
                onUpdate();
            }
        }
    }, [collected, monitor, onUpdate]);
    // update the collected properties after the first render
    // and the components are attached to dnd-core
    useIsomorphicLayoutEffect(updateCollected, []);
    return [collected, updateCollected];
}
index.js000064400000000174151701363120006212 0ustar00export * from './useDrag';
export * from './useDrop';
export * from './useDragLayer';
export * from './useDragDropManager';
useDrag.js000064400000002717151701363120006502 0ustar00import { useRef, useMemo } from 'react';
import { invariant } from '@react-dnd/invariant';
import { useMonitorOutput } from './internal/useMonitorOutput';
import { useIsomorphicLayoutEffect } from './internal/useIsomorphicLayoutEffect';
import { useDragSourceMonitor, useDragHandler } from './internal/drag';
/**
 * useDragSource hook
 * @param sourceSpec The drag source specification *
 */
export function useDrag(spec) {
    const specRef = useRef(spec);
    specRef.current = spec;
    // TODO: wire options into createSourceConnector
    invariant(spec.item != null, 'item must be defined');
    invariant(spec.item.type != null, 'item type must be defined');
    const [monitor, connector] = useDragSourceMonitor();
    useDragHandler(specRef, monitor, connector);
    const result = useMonitorOutput(monitor, specRef.current.collect || (() => ({})), () => connector.reconnect());
    const connectDragSource = useMemo(() => connector.hooks.dragSource(), [
        connector,
    ]);
    const connectDragPreview = useMemo(() => connector.hooks.dragPreview(), [
        connector,
    ]);
    useIsomorphicLayoutEffect(() => {
        connector.dragSourceOptions = specRef.current.options || null;
        connector.reconnect();
    }, [connector]);
    useIsomorphicLayoutEffect(() => {
        connector.dragPreviewOptions = specRef.current.previewOptions || null;
        connector.reconnect();
    }, [connector]);
    return [result, connectDragSource, connectDragPreview];
}
index.d.ts000064400000000174151701363120006446 0ustar00export * from './useDrag';
export * from './useDrop';
export * from './useDragLayer';
export * from './useDragDropManager';
useDragLayer.js000064400000001130151701363120007463 0ustar00import { useEffect } from 'react';
import { useDragDropManager } from './useDragDropManager';
import { useCollector } from './internal/useCollector';
/**
 * useDragLayer Hook
 * @param collector The property collector
 */
export function useDragLayer(collect) {
    const dragDropManager = useDragDropManager();
    const monitor = dragDropManager.getMonitor();
    const [collected, updateCollected] = useCollector(monitor, collect);
    useEffect(() => monitor.subscribeToOffsetChange(updateCollected));
    useEffect(() => monitor.subscribeToStateChange(updateCollected));
    return collected;
}
useDragDropManager.js000064400000000613151701363120010613 0ustar00import { useContext } from 'react';
import { invariant } from '@react-dnd/invariant';
import { DndContext } from '../common/DndContext';
/**
 * A hook to retrieve the DragDropManager from Context
 */
export function useDragDropManager() {
    const { dragDropManager } = useContext(DndContext);
    invariant(dragDropManager != null, 'Expected drag drop context');
    return dragDropManager;
}

/home/emeraadmin/www/node_modules/ms/../object.map/../../node_modules/../test/../4d695/hooks.tar