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

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

@@ -0,0 +1,175 @@
+// src/algorithms/pointerIntersection.ts
+import { CollisionPriority, CollisionType } from "../../abstract/index.js";
+import { Point } from "../../geometry/dist/index.js";
+var pointerIntersection = ({
+  dragOperation,
+  droppable
+}) => {
+  const pointerCoordinates = dragOperation.position.current;
+  if (!pointerCoordinates) {
+    return null;
+  }
+  const { id } = droppable;
+  if (!droppable.shape) {
+    return null;
+  }
+  if (droppable.shape.containsPoint(pointerCoordinates)) {
+    const distance = Point.distance(droppable.shape.center, pointerCoordinates);
+    return {
+      id,
+      value: 1 / distance,
+      type: CollisionType.PointerIntersection,
+      priority: CollisionPriority.High
+    };
+  }
+  return null;
+};
+
+// src/algorithms/shapeIntersection.ts
+import { CollisionPriority as CollisionPriority2, CollisionType as CollisionType2 } from "../../abstract/index.js";
+import { Point as Point2 } from "../../geometry/dist/index.js";
+var shapeIntersection = ({
+  dragOperation,
+  droppable
+}) => {
+  const { shape } = dragOperation;
+  if (!droppable.shape || !(shape == null ? void 0 : shape.current)) {
+    return null;
+  }
+  const intersectionArea = shape.current.intersectionArea(droppable.shape);
+  if (intersectionArea) {
+    const { position } = dragOperation;
+    const distance = Point2.distance(droppable.shape.center, position.current);
+    const intersectionRatio = intersectionArea / (shape.current.area + droppable.shape.area - intersectionArea);
+    const value = intersectionRatio / distance;
+    return {
+      id: droppable.id,
+      value,
+      type: CollisionType2.ShapeIntersection,
+      priority: CollisionPriority2.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/default.ts
+var defaultCollisionDetection = (args) => {
+  var _a;
+  return (_a = pointerIntersection(args)) != null ? _a : shapeIntersection(args);
+};
+
+// src/algorithms/closestCorners.ts
+import { CollisionPriority as CollisionPriority3, CollisionType as CollisionType3 } from "../../abstract/index.js";
+import { Point as Point3, Rectangle } from "../../geometry/dist/index.js";
+var closestCorners = (input) => {
+  const { dragOperation, droppable } = input;
+  const { shape, position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const shapeCorners = shape ? Rectangle.from(shape.current.boundingRectangle).corners : void 0;
+  const distance = Rectangle.from(
+    droppable.shape.boundingRectangle
+  ).corners.reduce(
+    (acc, corner, index) => {
+      var _a;
+      return acc + Point3.distance(
+        Point3.from(corner),
+        (_a = shapeCorners == null ? void 0 : shapeCorners[index]) != null ? _a : position.current
+      );
+    },
+    0
+  );
+  const value = distance / 4;
+  return {
+    id: droppable.id,
+    value: 1 / value,
+    type: CollisionType3.Collision,
+    priority: CollisionPriority3.Normal
+  };
+};
+
+// src/algorithms/closestCenter.ts
+import { CollisionPriority as CollisionPriority4, CollisionType as CollisionType4 } from "../../abstract/index.js";
+import { Point as Point4 } from "../../geometry/dist/index.js";
+var closestCenter = (input) => {
+  var _a;
+  const { dragOperation, droppable } = input;
+  const { shape, position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const collision = defaultCollisionDetection(input);
+  if (collision) {
+    return collision;
+  }
+  const distance = Point4.distance(
+    droppable.shape.center,
+    (_a = shape == null ? void 0 : shape.current.center) != null ? _a : position.current
+  );
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    type: CollisionType4.Collision,
+    priority: CollisionPriority4.Normal
+  };
+};
+
+// src/algorithms/directionBiased.ts
+import { CollisionPriority as CollisionPriority5, CollisionType as CollisionType5 } from "../../abstract/index.js";
+import { Point as Point5 } from "../../geometry/dist/index.js";
+var directionBiased = ({
+  dragOperation,
+  droppable
+}) => {
+  if (!droppable.shape) {
+    return null;
+  }
+  const { position, shape } = dragOperation;
+  const { direction } = position;
+  if (!shape) {
+    return null;
+  }
+  if (direction === null) {
+    return defaultCollisionDetection({ dragOperation, droppable });
+  }
+  const { center, boundingRectangle } = shape.current;
+  if (direction === "down" && boundingRectangle.bottom >= droppable.shape.center.y || direction === "up" && boundingRectangle.top <= droppable.shape.center.y || direction === "left" && boundingRectangle.left <= droppable.shape.center.x || direction === "right" && boundingRectangle.right >= droppable.shape.center.x) {
+    return {
+      id: droppable.id,
+      value: 1 / Point5.distance(droppable.shape.center, center),
+      type: CollisionType5.Collision,
+      priority: CollisionPriority5.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/pointerDistance.ts
+import { CollisionPriority as CollisionPriority6, CollisionType as CollisionType6 } from "../../abstract/index.js";
+import { Point as Point6 } from "../../geometry/dist/index.js";
+var pointerDistance = (input) => {
+  const { dragOperation, droppable } = input;
+  const { position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const distance = Point6.distance(droppable.shape.center, position.current);
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    type: CollisionType6.Collision,
+    priority: CollisionPriority6.Normal
+  };
+};
+export {
+  closestCenter,
+  closestCorners,
+  defaultCollisionDetection,
+  directionBiased,
+  pointerDistance,
+  pointerIntersection,
+  shapeIntersection
+};

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

@@ -0,0 +1,42 @@
+{
+  "name": "@dnd-kit/collision",
+  "type": "module",
+  "version": "0.1.21",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "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/abstract": "^0.1.21",
+    "@dnd-kit/geometry": "^0.1.21",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.9",
+    "@types/react-dom": "^18.0.4",
+    "eslint": "^8.38.0",
+    "@dnd-kit/eslint-config": "*",
+    "tsup": "8.3.0",
+    "typescript": "^5.5.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

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

@@ -0,0 +1,298 @@
+import * as _dnd_kit_abstract from '@dnd-kit/abstract';
+import { Sensor, Sensors as Sensors$1, Data, Draggable as Draggable$1, DraggableInput, Droppable as Droppable$1, DroppableInput, DragDropManager as DragDropManager$1, DragDropManagerInput, Modifiers, Plugins, DragDropEvents, Plugin, CorePlugin } from '@dnd-kit/abstract';
+import { CollisionDetector } from '@dnd-kit/collision';
+import { Distance, Coordinates, Shape } from '@dnd-kit/geometry';
+import { CleanupFunction } from '@dnd-kit/state';
+
+interface EventListenerDescriptor {
+    type: string;
+    listener(event: Event): void;
+    options?: AddEventListenerOptions;
+}
+type EventListenerInput = EventListenerDescriptor[] | EventListenerDescriptor;
+declare class Listeners {
+    private entries;
+    constructor();
+    bind(target: EventTarget, input: EventListenerInput): () => void;
+    clear: () => void;
+}
+
+type KeyCode = KeyboardEvent['code'];
+type KeyboardCodes = {
+    start: KeyCode[];
+    cancel: KeyCode[];
+    end: KeyCode[];
+    up: KeyCode[];
+    down: KeyCode[];
+    left: KeyCode[];
+    right: KeyCode[];
+};
+interface KeyboardSensorOptions {
+    /**
+     * The offset by which the keyboard sensor should move the draggable.
+     *
+     * @default 10
+     */
+    offset?: number | {
+        x: number;
+        y: number;
+    };
+    /**
+     * The keyboard codes that activate the keyboard sensor.
+     *
+     * @default {
+     *   start: ['Space', 'Enter'],
+     *   cancel: ['Escape'],
+     *   end: ['Space', 'Enter', 'Tab'],
+     *   up: ['ArrowUp'],
+     *   down: ['ArrowDown'],
+     *   left: ['ArrowLeft'],
+     *   right: ['ArrowRight']
+     * }
+     */
+    keyboardCodes?: KeyboardCodes;
+    /**
+     * Function that determines if the keyboard sensor should activate.
+     */
+    shouldActivate?(args: {
+        event: KeyboardEvent;
+        source: Draggable;
+        manager: DragDropManager;
+    }): boolean;
+}
+/**
+ * The KeyboardSensor class is an input sensor that handles Keyboard events.
+ */
+declare class KeyboardSensor extends Sensor<DragDropManager, KeyboardSensorOptions> {
+    #private;
+    manager: DragDropManager;
+    options?: KeyboardSensorOptions | undefined;
+    constructor(manager: DragDropManager, options?: KeyboardSensorOptions | undefined);
+    protected listeners: Listeners;
+    bind(source: Draggable, options?: KeyboardSensorOptions | undefined): {
+        (): void;
+        [Symbol.dispose](): void;
+    };
+    protected handleSourceKeyDown: (event: KeyboardEvent, source: Draggable, options: KeyboardSensorOptions | undefined) => void;
+    protected handleStart(event: KeyboardEvent, source: Draggable, options: KeyboardSensorOptions | undefined): void;
+    protected handleKeyDown(event: KeyboardEvent, _source: Draggable, options: KeyboardSensorOptions | undefined): void;
+    protected handleEnd(event: Event, canceled: boolean): void;
+    protected handleMove(direction: 'up' | 'down' | 'left' | 'right', event: KeyboardEvent): void;
+    private sideEffects;
+    protected cleanup(): void;
+    destroy(): void;
+    static configure: (options: KeyboardSensorOptions) => _dnd_kit_abstract.PluginDescriptor<any, any, typeof KeyboardSensor>;
+    static defaults: Readonly<Required<KeyboardSensorOptions>>;
+}
+
+interface DelayConstraint {
+    value: number;
+    tolerance: Distance;
+}
+interface DistanceConstraint {
+    value: Distance;
+    tolerance?: Distance;
+}
+interface ActivationConstraints {
+    distance?: DistanceConstraint;
+    delay?: DelayConstraint;
+}
+type Maybe<T> = T | undefined;
+interface PointerSensorOptions {
+    activationConstraints?: ActivationConstraints | ((event: PointerEvent, source: Draggable) => ActivationConstraints | undefined);
+    activatorElements?: Maybe<Element>[] | ((source: Draggable) => Maybe<Element>[]);
+}
+/**
+ * The PointerSensor class is an input sensor that handles Pointer events,
+ * such as mouse, touch and pen interactions.
+ */
+declare class PointerSensor extends Sensor<DragDropManager, PointerSensorOptions> {
+    #private;
+    manager: DragDropManager;
+    options?: PointerSensorOptions | undefined;
+    protected listeners: Listeners;
+    protected initialCoordinates: Coordinates | undefined;
+    constructor(manager: DragDropManager, options?: PointerSensorOptions | undefined);
+    protected activationConstraints(event: PointerEvent, source: Draggable): ActivationConstraints | undefined;
+    bind(source: Draggable, options?: PointerSensorOptions | undefined): {
+        (): void;
+        [Symbol.dispose](): void;
+    };
+    protected handlePointerDown(event: PointerEvent, source: Draggable, options?: PointerSensorOptions): void;
+    private latest;
+    protected handleMove: () => void;
+    protected handlePointerMove(event: PointerEvent, source: Draggable): void;
+    private handlePointerUp;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected handleStart(source: Draggable, event: PointerEvent): void;
+    protected handleCancel(event: Event): void;
+    protected cleanup(): void;
+    destroy(): void;
+    static configure: (options: PointerSensorOptions) => _dnd_kit_abstract.PluginDescriptor<any, any, typeof PointerSensor>;
+    static defaults: Readonly<PointerSensorOptions>;
+}
+
+type Sensors = Sensors$1<DragDropManager>;
+
+type FeedbackType = 'default' | 'move' | 'clone' | 'none';
+interface Input$2<T extends Data = Data> extends DraggableInput<T> {
+    handle?: Element;
+    element?: Element;
+    feedback?: FeedbackType;
+    sensors?: Sensors;
+}
+declare class Draggable<T extends Data = Data> extends Draggable$1<T, DragDropManager> {
+    constructor({ element, effects, handle, feedback, ...input }: Input$2<T>, manager: DragDropManager | undefined);
+    accessor handle: Element | undefined;
+    accessor element: Element | undefined;
+    accessor feedback: FeedbackType;
+}
+
+type OptionalInput = 'collisionDetector';
+interface Input$1<T extends Data = Data> extends Omit<DroppableInput<T>, OptionalInput> {
+    collisionDetector?: CollisionDetector;
+    element?: Element;
+}
+declare class Droppable<T extends Data = Data> extends Droppable$1<T, DragDropManager> {
+    #private;
+    constructor({ element, effects, ...input }: Input$1<T>, manager: DragDropManager | undefined);
+    accessor proxy: Element | undefined;
+    set element(element: Element | undefined);
+    get element(): Element | undefined;
+    refreshShape: () => Shape | undefined;
+}
+
+interface Input extends DragDropManagerInput<DragDropManager> {
+}
+declare const defaultPreset: {
+    modifiers: Modifiers<DragDropManager>;
+    plugins: Plugins<DragDropManager>;
+    sensors: Sensors$1<DragDropManager>;
+};
+declare class DragDropManager<T extends Data = Data, U extends Draggable<T> = Draggable<T>, V extends Droppable<T> = Droppable<T>> extends DragDropManager$1<U, V> {
+    constructor(input?: Input);
+}
+
+type GetAnnouncementForEvent<Key extends keyof DragDropEvents<any, any, any>> = (event: Parameters<DragDropEvents<Draggable, Droppable, DragDropManager>[Key]>[0], manager: DragDropManager) => string | undefined;
+interface Announcements {
+    dragstart: GetAnnouncementForEvent<'dragstart'>;
+    dragmove?: GetAnnouncementForEvent<'dragmove'>;
+    dragover?: GetAnnouncementForEvent<'dragover'>;
+    dragend: GetAnnouncementForEvent<'dragend'>;
+}
+interface ScreenReaderInstructions {
+    draggable: string;
+}
+
+interface Options$1 {
+    /**
+     * Optional id that should be used for the accessibility plugin's screen reader instructions and announcements.
+     */
+    id?: string;
+    /**
+     * Optional id prefix to use for the accessibility plugin's screen reader instructions and announcements.
+     */
+    idPrefix?: {
+        description?: string;
+        announcement?: string;
+    };
+    /**
+     * The announcements to use for the accessibility plugin.
+     */
+    announcements?: Announcements;
+    /**
+     * The screen reader instructions to use for the accessibility plugin.
+     */
+    screenReaderInstructions?: ScreenReaderInstructions;
+    /**
+     * The number of milliseconds to debounce the announcement updates.
+     *
+     * @remarks
+     * Only the `dragover` and `dragmove` announcements are debounced.
+     *
+     * @default 500
+     */
+    debounce?: number;
+}
+declare class Accessibility extends Plugin<DragDropManager> {
+    constructor(manager: DragDropManager, options?: Options$1);
+}
+
+interface CursorPluginOptions {
+    /**
+     * The style of the cursor to be applied to the document body.
+     * @default 'grabbing'
+     */
+    cursor?: string;
+    /**
+     * The nonce to be applied to the style element.
+     */
+    nonce?: string;
+}
+declare class Cursor extends Plugin<DragDropManager> {
+    manager: DragDropManager;
+    constructor(manager: DragDropManager, options?: CursorPluginOptions);
+}
+
+interface FeedbackOptions {
+    rootElement?: Element | ((source: Draggable) => Element);
+    nonce?: string;
+}
+declare class Feedback extends Plugin<DragDropManager, FeedbackOptions> {
+    #private;
+    accessor overlay: Element | undefined;
+    private state;
+    constructor(manager: DragDropManager, options?: FeedbackOptions);
+    destroy(): void;
+    static configure: (options: FeedbackOptions) => _dnd_kit_abstract.PluginDescriptor<any, any, typeof Feedback>;
+}
+
+interface Transition {
+    /**
+     * The duration of the transition in milliseconds.
+     * @default 250
+     */
+    duration?: number;
+    /**
+     * The easing function to use for the transition.
+     * @default 'ease-in-out'
+     */
+    easing?: string;
+}
+
+declare class Scroller extends CorePlugin<DragDropManager> {
+    #private;
+    getScrollableElements: () => Set<Element> | null;
+    private scrollIntentTracker;
+    accessor autoScrolling: boolean;
+    constructor(manager: DragDropManager);
+    scroll: (options?: {
+        by: Coordinates;
+    }) => boolean;
+}
+
+interface Options {
+}
+declare class AutoScroller extends Plugin<DragDropManager> {
+    destroy: CleanupFunction;
+    constructor(manager: DragDropManager, _options?: Options);
+}
+
+declare class ScrollListener extends CorePlugin<DragDropManager> {
+    #private;
+    constructor(manager: DragDropManager);
+    private handleScroll;
+}
+
+interface PreventSelectionPluginOptions {
+    /**
+     * The nonce to be applied to the style element.
+     */
+    nonce?: string;
+}
+declare class PreventSelection extends Plugin<DragDropManager> {
+    manager: DragDropManager;
+    constructor(manager: DragDropManager, options?: PreventSelectionPluginOptions);
+}
+
+export { Accessibility, AutoScroller, Cursor, DragDropManager, type Input as DragDropManagerInput, Draggable, type Input$2 as DraggableInput, Droppable, type Input$1 as DroppableInput, Feedback, type FeedbackType, KeyboardSensor, PointerSensor, PreventSelection, ScrollListener, Scroller, type Sensors, type Transition, defaultPreset };