@vuu-ui/vuu-utils 3.1.0-beta.2 → 3.1.0-beta.4

package/src/vendor/@dnd-kit/geometry/dist/index.js

@@ -0,0 +1,347 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decoratorStart = (base) => {
+  var _a2;
+  return [, , , __create((_a2 = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a2 : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Axes: () => Axes,
+  Axis: () => Axis,
+  Point: () => Point,
+  Position: () => Position,
+  Rectangle: () => Rectangle,
+  exceedsDistance: () => exceedsDistance
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/point/Point.ts
+var Point = class _Point {
+  /**
+   * @param {number} Coordinate of the point on the horizontal axis
+   * @param {number} Coordinate of the point on the vertical axis
+   */
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  /**
+   * Returns the delta between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static delta(a, b) {
+    return new _Point(a.x - b.x, a.y - b.y);
+  }
+  /**
+   * Returns the distance (hypotenuse) between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static distance(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+  }
+  /**
+   * Returns true if both points are equal.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static equals(a, b) {
+    return a.x === b.x && a.y === b.y;
+  }
+  static from({ x, y }) {
+    return new _Point(x, y);
+  }
+};
+
+// src/shapes/Rectangle.ts
+var Rectangle = class _Rectangle {
+  constructor(left, top, width, height) {
+    this.left = left;
+    this.top = top;
+    this.width = width;
+    this.height = height;
+    this.scale = {
+      x: 1,
+      y: 1
+    };
+  }
+  get inverseScale() {
+    return {
+      x: 1 / this.scale.x,
+      y: 1 / this.scale.y
+    };
+  }
+  translate(x, y) {
+    const { top, left, width, height, scale } = this;
+    const newShape = new _Rectangle(left + x, top + y, width, height);
+    newShape.scale = __spreadValues({}, scale);
+    return newShape;
+  }
+  get boundingRectangle() {
+    const { width, height, left, top, right, bottom } = this;
+    return { width, height, left, top, right, bottom };
+  }
+  get center() {
+    const { left, top, right, bottom } = this;
+    return new Point((left + right) / 2, (top + bottom) / 2);
+  }
+  get area() {
+    const { width, height } = this;
+    return width * height;
+  }
+  equals(shape) {
+    if (!(shape instanceof _Rectangle)) {
+      return false;
+    }
+    const { left, top, width, height } = this;
+    return left === shape.left && top === shape.top && width === shape.width && height === shape.height;
+  }
+  containsPoint(point) {
+    const { top, left, bottom, right } = this;
+    return top <= point.y && point.y <= bottom && left <= point.x && point.x <= right;
+  }
+  intersectionArea(shape) {
+    if (shape instanceof _Rectangle) {
+      return rectangleRectangleIntersection(this, shape);
+    }
+    return 0;
+  }
+  intersectionRatio(shape) {
+    const { area } = this;
+    const intersectionArea = this.intersectionArea(shape);
+    const intersectionRatio = intersectionArea / (shape.area + area - intersectionArea);
+    return intersectionRatio;
+  }
+  get bottom() {
+    const { top, height } = this;
+    return top + height;
+  }
+  get right() {
+    const { left, width } = this;
+    return left + width;
+  }
+  get aspectRatio() {
+    const { width, height } = this;
+    return width / height;
+  }
+  get corners() {
+    return [
+      { x: this.left, y: this.top },
+      { x: this.right, y: this.top },
+      { x: this.left, y: this.bottom },
+      { x: this.right, y: this.bottom }
+    ];
+  }
+  static from({ top, left, width, height }) {
+    return new _Rectangle(left, top, width, height);
+  }
+  static delta(a, b, alignment = { x: "center", y: "center" }) {
+    const getCoordinate = (rect, axis) => {
+      const align = alignment[axis];
+      const start = axis === "x" ? rect.left : rect.top;
+      const size = axis === "x" ? rect.width : rect.height;
+      if (align == "start") return start;
+      if (align == "end") return start + size;
+      return start + size / 2;
+    };
+    return Point.delta(
+      { x: getCoordinate(a, "x"), y: getCoordinate(a, "y") },
+      { x: getCoordinate(b, "x"), y: getCoordinate(b, "y") }
+    );
+  }
+  static intersectionRatio(a, b) {
+    return _Rectangle.from(a).intersectionRatio(_Rectangle.from(b));
+  }
+};
+function rectangleRectangleIntersection(a, b) {
+  const top = Math.max(b.top, a.top);
+  const left = Math.max(b.left, a.left);
+  const right = Math.min(b.left + b.width, a.left + a.width);
+  const bottom = Math.min(b.top + b.height, a.top + a.height);
+  const width = right - left;
+  const height = bottom - top;
+  if (left < right && top < bottom) {
+    const intersectionArea = width * height;
+    return intersectionArea;
+  }
+  return 0;
+}
+
+// src/position/position.ts
+var import_state = require("../../state/dist/index.js");
+var _direction_dec, _delta_dec, _a, _timestamp, _init;
+var Position = class extends (_a = import_state.ValueHistory, _delta_dec = [import_state.derived], _direction_dec = [import_state.derived], _a) {
+  constructor(initialValue) {
+    const point = Point.from(initialValue);
+    super(point, (a, b) => Point.equals(a, b));
+    __runInitializers(_init, 5, this);
+    __privateAdd(this, _timestamp, 0);
+    this.velocity = { x: 0, y: 0 };
+  }
+  get delta() {
+    return Point.delta(this.current, this.initial);
+  }
+  get direction() {
+    const { current, previous } = this;
+    if (!previous) return null;
+    const delta = {
+      x: current.x - previous.x,
+      y: current.y - previous.y
+    };
+    if (!delta.x && !delta.y) {
+      return null;
+    }
+    if (Math.abs(delta.x) > Math.abs(delta.y)) {
+      return delta.x > 0 ? "right" : "left";
+    }
+    return delta.y > 0 ? "down" : "up";
+  }
+  get current() {
+    return super.current;
+  }
+  set current(coordinates) {
+    const { current } = this;
+    const point = Point.from(coordinates);
+    const delta = {
+      x: point.x - current.x,
+      y: point.y - current.y
+    };
+    const timestamp = Date.now();
+    const timeDelta = timestamp - __privateGet(this, _timestamp);
+    const velocity = (delta2) => Math.round(delta2 / timeDelta * 100);
+    (0, import_state.batch)(() => {
+      __privateSet(this, _timestamp, timestamp);
+      this.velocity = {
+        x: velocity(delta.x),
+        y: velocity(delta.y)
+      };
+      super.current = point;
+    });
+  }
+  reset(coordinates = this.defaultValue) {
+    super.reset(Point.from(coordinates));
+    this.velocity = { x: 0, y: 0 };
+  }
+};
+_init = __decoratorStart(_a);
+_timestamp = new WeakMap();
+__decorateElement(_init, 2, "delta", _delta_dec, Position);
+__decorateElement(_init, 2, "direction", _direction_dec, Position);
+__decoratorMetadata(_init, Position);
+
+// src/distance/distance.ts
+function exceedsDistance({ x, y }, distance) {
+  const dx = Math.abs(x);
+  const dy = Math.abs(y);
+  if (typeof distance === "number") {
+    return Math.sqrt(__pow(dx, 2) + __pow(dy, 2)) > distance;
+  }
+  if ("x" in distance && "y" in distance) {
+    return dx > distance.x && dy > distance.y;
+  }
+  if ("x" in distance) {
+    return dx > distance.x;
+  }
+  if ("y" in distance) {
+    return dy > distance.y;
+  }
+  return false;
+}
+
+// src/types/axis.ts
+var Axis = /* @__PURE__ */ ((Axis2) => {
+  Axis2["Horizontal"] = "x";
+  Axis2["Vertical"] = "y";
+  return Axis2;
+})(Axis || {});
+var Axes = Object.values(Axis);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Axes,
+  Axis,
+  Point,
+  Position,
+  Rectangle,
+  exceedsDistance
+});

package/src/vendor/@dnd-kit/geometry/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dnd-kit/geometry",
+  "version": "0.1.21",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
+    "lint": "TIMING=1 eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "@dnd-kit/state": "^0.1.21",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@dnd-kit/eslint-config": "*",
+    "eslint": "^8.38.0",
+    "tsup": "8.3.0",
+    "typescript": "^5.5.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/vendor/@dnd-kit/react/hooks.d.ts

@@ -0,0 +1,30 @@
+import * as react from 'react';
+import { EffectCallback, DependencyList, useLayoutEffect, useEffect, RefObject, MutableRefObject } from 'react';
+
+declare function useConstant<T = any>(initializer: () => T): T;
+
+declare function useComputed<T = any>(compute: () => T, dependencies?: any[], sync?: boolean): {
+    readonly value: T;
+};
+
+/** Trigger a re-render when reading signal properties of an object. */
+declare function useDeepSignal<T extends object | null | undefined>(target: T, synchronous?: (property: keyof T, oldValue: any, newValue: any) => boolean): T;
+
+declare function useImmediateEffect(callback: EffectCallback, _?: DependencyList): void;
+
+/**
+ * A hook that resolves to useEffect on the server and useLayoutEffect on the client
+ * @param callback {function} Callback function that is invoked when the dependencies of the hook change
+ */
+declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+
+declare function useLatest<T>(value: T): react.RefObject<T | undefined>;
+
+declare function useOnValueChange<T>(value: T, onChange: (value: T, oldValue: T) => void, effect?: typeof useEffect, compare?: (value1: any, value2: any) => boolean): void;
+
+type Ref<T> = RefObject<T | null | undefined> | MutableRefObject<T>;
+type RefOrValue<T> = T | Ref<T> | null | undefined;
+
+declare function useOnElementChange(value: RefOrValue<Element>, onChange: (value: Element | undefined) => void): void;
+
+export { useComputed, useConstant, useDeepSignal, useImmediateEffect, useIsomorphicLayoutEffect, useLatest, useOnElementChange, useOnValueChange };

package/src/vendor/@dnd-kit/react/hooks.js

@@ -0,0 +1,133 @@
+import { useLayoutEffect, useEffect, useRef, useMemo, useState, useCallback } from 'react';
+import { computed, effect, untracked } from '../state/dist/index.js';
+import { flushSync } from 'react-dom';
+import { currentValue } from './utilities.js';
+
+function useConstant(initializer) {
+  const ref = useRef(null);
+  if (!ref.current) {
+    ref.current = initializer();
+  }
+  return ref.current;
+}
+var canUseDOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+var useIsomorphicLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;
+function useForceUpdate() {
+  const setState = useState(0)[1];
+  return useCallback(() => {
+    setState((value) => value + 1);
+  }, [setState]);
+}
+
+// src/hooks/useSignal.ts
+function useSignal(signal, sync = false) {
+  const previous = useRef(signal.peek());
+  const read = useRef(false);
+  const forceUpdate = useForceUpdate();
+  useIsomorphicLayoutEffect(
+    () => effect(() => {
+      const previousValue = previous.current;
+      const currentValue2 = signal.value;
+      if (previousValue !== currentValue2) {
+        previous.current = currentValue2;
+        if (!read.current) return;
+        if (sync) {
+          flushSync(forceUpdate);
+        } else {
+          forceUpdate();
+        }
+      }
+    }),
+    [signal, sync, forceUpdate]
+  );
+  return {
+    get value() {
+      read.current = true;
+      return signal.peek();
+    }
+  };
+}
+
+// src/hooks/useComputed.ts
+function useComputed(compute, dependencies = [], sync = false) {
+  const $compute = useRef(compute);
+  $compute.current = compute;
+  return useSignal(
+    useMemo(() => computed(() => $compute.current()), dependencies),
+    sync
+  );
+}
+function useDeepSignal(target, synchronous) {
+  const tracked = useRef(/* @__PURE__ */ new Map());
+  const forceUpdate = useForceUpdate();
+  useIsomorphicLayoutEffect(() => {
+    if (!target) {
+      tracked.current.clear();
+      return;
+    }
+    return effect(() => {
+      var _a;
+      let stale = false;
+      let sync = false;
+      for (const entry of tracked.current) {
+        const [key] = entry;
+        const value = untracked(() => entry[1]);
+        const latestValue = target[key];
+        if (value !== latestValue) {
+          stale = true;
+          tracked.current.set(key, latestValue);
+          sync = (_a = synchronous == null ? void 0 : synchronous(key, value, latestValue)) != null ? _a : false;
+        }
+      }
+      if (stale) {
+        sync ? flushSync(forceUpdate) : forceUpdate();
+      }
+    });
+  }, [target]);
+  return useMemo(
+    () => target ? new Proxy(target, {
+      get(target2, key) {
+        const value = target2[key];
+        tracked.current.set(key, value);
+        return value;
+      }
+    }) : target,
+    [target]
+  );
+}
+
+// src/hooks/useImmediateEffect.ts
+function useImmediateEffect(callback, _) {
+  callback();
+}
+function useLatest(value) {
+  const valueRef = useRef(value);
+  useIsomorphicLayoutEffect(() => {
+    valueRef.current = value;
+  }, [value]);
+  return valueRef;
+}
+function useOnValueChange(value, onChange, effect3 = useEffect, compare = Object.is) {
+  const tracked = useRef(value);
+  effect3(() => {
+    const oldValue = tracked.current;
+    if (!compare(value, oldValue)) {
+      tracked.current = value;
+      onChange(value, oldValue);
+    }
+  }, [onChange, value]);
+}
+function useOnElementChange(value, onChange) {
+  const previous = useRef(currentValue(value));
+  useIsomorphicLayoutEffect(() => {
+    const current = currentValue(value);
+    if (current !== previous.current) {
+      previous.current = current;
+      onChange(current);
+    }
+  });
+}
+
+export { useComputed, useConstant, useDeepSignal, useImmediateEffect, useIsomorphicLayoutEffect, useLatest, useOnElementChange, useOnValueChange };
+//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=hooks.js.map

package/src/vendor/@dnd-kit/react/index.d.ts

@@ -0,0 +1,84 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { PropsWithChildren, RefObject, MutableRefObject, ReactNode } from 'react';
+import { Data, DragDropEvents, DragDropManager as DragDropManager$1 } from '@dnd-kit/abstract';
+import { Draggable, Droppable, DragDropManager, DragDropManagerInput, DraggableInput, DroppableInput } from '@dnd-kit/dom';
+export { DragDropManager, KeyboardSensor, PointerSensor } from '@dnd-kit/dom';
+import { CleanupFunction } from '@dnd-kit/state';
+
+type Events$1<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>> = DragDropEvents<U, V, W>;
+interface Props$1<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>> extends DragDropManagerInput, PropsWithChildren {
+    manager?: W;
+    onBeforeDragStart?: Events$1<T, U, V, W>['beforedragstart'];
+    onCollision?: Events$1<T, U, V, W>['collision'];
+    onDragStart?: Events$1<T, U, V, W>['dragstart'];
+    onDragMove?: Events$1<T, U, V, W>['dragmove'];
+    onDragOver?: Events$1<T, U, V, W>['dragover'];
+    onDragEnd?: Events$1<T, U, V, W>['dragend'];
+}
+declare function DragDropProvider<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>>({ children, onCollision, onBeforeDragStart, onDragStart, onDragMove, onDragOver, onDragEnd, ...input }: Props$1<T, U, V, W>): react_jsx_runtime.JSX.Element;
+
+type Ref<T> = RefObject<T | null | undefined> | MutableRefObject<T>;
+type RefOrValue<T> = T | Ref<T> | null | undefined;
+
+interface UseDraggableInput<T extends Data = Data> extends Omit<DraggableInput<T>, 'handle' | 'element'> {
+    handle?: RefOrValue<Element>;
+    element?: RefOrValue<Element>;
+}
+declare function useDraggable<T extends Data = Data>(input: UseDraggableInput<T>): {
+    draggable: Draggable<T>;
+    readonly isDragging: boolean;
+    readonly isDropping: boolean;
+    readonly isDragSource: boolean;
+    handleRef: (element: Element | null) => void;
+    ref: (element: Element | null) => void;
+};
+
+interface Props<T extends Data, U extends Draggable<T>> {
+    className?: string;
+    children: ReactNode | ((source: U) => ReactNode);
+    style?: React.CSSProperties;
+    tag?: string;
+    disabled?: boolean | ((source: U | null) => boolean);
+}
+declare function DragOverlay<T extends Data, U extends Draggable<T>>({ children, className, style, tag, disabled, }: Props<T, U>): react_jsx_runtime.JSX.Element;
+
+interface UseDroppableInput<T extends Data = Data> extends Omit<DroppableInput<T>, 'element'> {
+    element?: RefOrValue<Element>;
+}
+declare function useDroppable<T extends Data = Data>(input: UseDroppableInput<T>): {
+    droppable: Droppable<T>;
+    readonly isDropTarget: boolean;
+    ref: (element: Element | null) => void;
+};
+
+declare function useDragDropManager<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>>(): W | null;
+
+type DragDropEventMap = {
+    beforedragstart: 'onBeforeDragStart';
+};
+type EventHandlerName<T extends string> = T extends keyof DragDropEventMap ? DragDropEventMap[T] : T extends `drag${infer Second}${infer Rest}` ? `onDrag${Uppercase<Second>}${Rest}` : `on${Capitalize<T>}`;
+/**
+ * Type for all possible event handlers
+ */
+type Events<T extends Data, U extends Draggable<T>, V extends Droppable<T>, W extends DragDropManager<T, U, V>> = DragDropEvents<U, V, W>;
+type EventHandlers<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>> = {
+    [K in keyof Events<T, U, V, W> as EventHandlerName<K>]: Events<T, U, V, W>[K];
+};
+/**
+ * Hook to monitor drag and drop events anywhere within a DragDropProvider
+ * @param handlers Object containing event handlers for drag and drop events
+ */
+declare function useDragDropMonitor<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>>(handlers: Partial<EventHandlers<T, U, V, W>>): void;
+
+declare function useDragOperation<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>, W extends DragDropManager<T, U, V> = DragDropManager<T, U, V>>(): {
+    readonly source: U | null | undefined;
+    readonly target: V | null | undefined;
+};
+
+interface Instance<T extends DragDropManager$1<any, any> = DragDropManager$1<any, any>> {
+    manager: T | undefined;
+    register(): CleanupFunction | void;
+}
+declare function useInstance<T extends Instance>(initializer: (manager: DragDropManager$1<any, any> | undefined) => T): T;
+
+export { type EventHandlers as DragDropEventHandlers, type Events$1 as DragDropEvents, DragDropProvider, DragOverlay, type UseDraggableInput, type UseDroppableInput, useDragDropManager, useDragDropMonitor, useDragOperation, useDraggable, useDroppable, useInstance };