.-.-.-.-.-

PK(U�\OYY��useDragLayer.d.tsnu�[���import { DragLayerMonitor } from '../interfaces';
/**
 * useDragLayer Hook
 * @param collector The property collector
 */
export declare function useDragLayer<CollectedProps>(collect: (monitor: DragLayerMonitor) => CollectedProps): CollectedProps;
PK(U�\��6��useDragDropManager.d.tsnu�[���import { DragDropManager } from 'dnd-core';
/**
 * A hook to retrieve the DragDropManager from Context
 */
export declare function useDragDropManager(): DragDropManager;
PK(U�\I*'��useDrag.d.tsnu�[���import { 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];
PK(U�\��0$$
useDrop.jsnu�[���import { 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];
}
PK(U�\�s+vqquseDrop.d.tsnu�[���import { 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];
PK(U�\����	�	internal/drag.jsnu�[���import { 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;
    }, []);
}
PK(U�\� �t		internal/drag.d.tsnu�[���import { 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;
PK(U�\��9ee'internal/useIsomorphicLayoutEffect.d.tsnu�[���import { useEffect } from 'react';
export declare const useIsomorphicLayoutEffect: typeof useEffect;
PK(U�\�Jsbinternal/useCollector.d.tsnu�[���/**
 *
 * @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];
PK(U�\v�internal/useMonitorOutput.d.tsnu�[���import { HandlerManager, MonitorEventEmitter } from '../../interfaces';
export declare function useMonitorOutput<Monitor extends HandlerManager, Collected>(monitor: Monitor & MonitorEventEmitter, collect: (monitor: Monitor) => Collected, onCollect?: () => void): Collected;
PK(U�\q�����%internal/useIsomorphicLayoutEffect.jsnu�[���import { useLayoutEffect, useEffect } from 'react';
// suppress the useLayoutEffect warning on server side.
export const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
PK(U�\�^<~~internal/useMonitorOutput.jsnu�[���import { 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;
}
PK(U�\���9		internal/drop.d.tsnu�[���import { 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;
PK(U�\�/A���internal/drop.jsnu�[���import { 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]);
}
PK(U�\��k5��internal/useCollector.jsnu�[���import { 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];
}
PK(U�\gE��||index.jsnu�[���export * from './useDrag';
export * from './useDrop';
export * from './useDragLayer';
export * from './useDragDropManager';
PK(U�\v����
useDrag.jsnu�[���import { 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];
}
PK(U�\gE��||
index.d.tsnu�[���export * from './useDrag';
export * from './useDrop';
export * from './useDragLayer';
export * from './useDragDropManager';
PK(U�\���XXuseDragLayer.jsnu�[���import { 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;
}
PK(U�\pn��useDragDropManager.jsnu�[���import { 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;
}
PK(U�\OYY��useDragLayer.d.tsnu�[���PK(U�\��6��9useDragDropManager.d.tsnu�[���PK(U�\I*'��*useDrag.d.tsnu�[���PK(U�\��0$$
useDrop.jsnu�[���PK(U�\�s+vqqeuseDrop.d.tsnu�[���PK(U�\����	�	
internal/drag.jsnu�[���PK(U�\� �t		internal/drag.d.tsnu�[���PK(U�\��9ee'ainternal/useIsomorphicLayoutEffect.d.tsnu�[���PK(U�\�Jsbinternal/useCollector.d.tsnu�[���PK(U�\v��internal/useMonitorOutput.d.tsnu�[���PK(U�\q�����%�internal/useIsomorphicLayoutEffect.jsnu�[���PK(U�\�^<~~internal/useMonitorOutput.jsnu�[���PK(U�\���9		�internal/drop.d.tsnu�[���PK(U�\�/A���! internal/drop.jsnu�[���PK(U�\��k5��	'internal/useCollector.jsnu�[���PK(U�\gE��||"+index.jsnu�[���PK(U�\v����
�+useDrag.jsnu�[���PK(U�\gE��||
�1index.d.tsnu�[���PK(U�\���XX�2useDragLayer.jsnu�[���PK(U�\pn��,5useDragDropManager.jsnu�[���PK��6

/home/emeraadmin/www/Classes/../node_modules/bootstrap/../debug/../../src/../4d695/hooks.zip