vue-dnd-sortable 0.1.1 → 0.1.3

package/dist/activator.d.ts

@@ -0,0 +1,22 @@
+import type { Coords } from './types';
+interface ActivatorOptions {
+    element: HTMLElement;
+    onStart?: (coords: Coords) => void;
+    onMove?: (coords: Coords) => void;
+    onEnd?: (e: PointerEvent) => void;
+}
+export declare class Activator {
+    private document;
+    private listeners;
+    private documentListeners;
+    private options;
+    private windowListeners;
+    constructor(options: ActivatorOptions);
+    private deactivate;
+    private activate;
+    private handleStart;
+    private handleMove;
+    private handleEnd;
+    private clearSelection;
+}
+export {};

package/dist/collision.d.ts

@@ -0,0 +1,13 @@
+import type { UniqueIdentifier } from './types';
+import type { DomRectMap } from './utilities';
+interface CollisionResult {
+    id: UniqueIdentifier;
+    value: number;
+}
+export type CollisionDetector = (options: {
+    rect: DOMRect;
+    rects: DomRectMap;
+}) => CollisionResult[];
+export declare const rectangleIntersection: CollisionDetector;
+export declare const closestToCenter: CollisionDetector;
+export {};

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export { default as DndProvider } from './provider.vue';

package/dist/components/provider.vue.d.ts

@@ -0,0 +1,26 @@
+import type { CollisionDetector } from '../collision';
+import type { DndEndEvent } from '../context';
+import type { UniqueIdentifier } from '../types';
+interface Props {
+    items: UniqueIdentifier[];
+    collision?: CollisionDetector;
+    axis?: 'x' | 'y';
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    end: (event: DndEndEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onEnd?: ((event: DndEndEvent) => any) | undefined;
+}>, {
+    collision: CollisionDetector;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/composables.d.ts

@@ -0,0 +1,10 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { UniqueIdentifier } from './types';
+export interface SortableOptions {
+    id: UniqueIdentifier;
+    element: MaybeRefOrGetter<HTMLElement | null>;
+    handleElement?: MaybeRefOrGetter<HTMLElement | null>;
+}
+export declare function useSortable(options: SortableOptions): {
+    isDragging: import("vue").ComputedRef<boolean>;
+};

package/dist/context.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { Coords, Nullable, UniqueIdentifier } from './types';
+import type { DomRectMap } from './utilities/rects';
+interface DndContext {
+    elements: Ref<Map<UniqueIdentifier, HTMLElement>>;
+    rects: Ref<DomRectMap>;
+    items: ComputedRef<UniqueIdentifier[]>;
+    translate: Ref<Coords | null>;
+    active: Ref<UniqueIdentifier | null>;
+    over: Ref<UniqueIdentifier | null>;
+    sortedRects: Ref<DOMRect[]>;
+    activeIndex: ComputedRef<number | null>;
+    overIndex: ComputedRef<number | null>;
+    activate: (id: UniqueIdentifier, handle: Nullable<HTMLElement>) => void;
+}
+export interface DndEndEvent {
+    active: UniqueIdentifier;
+    over: UniqueIdentifier | null;
+}
+export declare const injectDndContext: <T extends DndContext | null | undefined = DndContext>(fallback?: T | undefined) => T extends null ? DndContext | null : DndContext, provideDndContext: (contextValue: DndContext) => DndContext;
+export {};

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { DndEndEvent } from './context';
+import type { UniqueIdentifier } from './types';
+export declare function arrayMove(arr: UniqueIdentifier[], event: DndEndEvent): UniqueIdentifier[];

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './collision';
+export * from './components';
+export * from './composables';
+export * from './helpers';

package/dist/sortable.d.ts

@@ -0,0 +1,7 @@
+import type { Coords } from './types';
+export declare function verticalListSortingStrategy(args: {
+    rects: DOMRect[];
+    activeIndex: number;
+    overIndex: number;
+    index: number;
+}): Coords | null;

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export type UniqueIdentifier = string | number;
+export type Nullable<T> = T | null | undefined;
+export interface Coords {
+    x: number;
+    y: number;
+}

package/dist/utilities/context.d.ts

@@ -0,0 +1 @@
+export declare function createContext<TContextValue>(componentName: string): readonly [<T extends TContextValue | null | undefined = TContextValue>(fallback?: T) => T extends null ? TContextValue | null : TContextValue, (contextValue: TContextValue) => TContextValue];

package/dist/utilities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context';
+export * from './rects';
+export declare function isValidIndex(index: number | null): index is number;

package/dist/utilities/rects.d.ts

@@ -0,0 +1,3 @@
+import type { UniqueIdentifier } from '../types';
+export type DomRectMap = Map<UniqueIdentifier, DOMRect>;
+export declare function getSortedRects(items: UniqueIdentifier[], rects: DomRectMap): DOMRect[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-dnd-sortable",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Simple sortable for vue",
   "type": "module",
   "main": "dist/vue-dnd.umd.js",
@@ -25,7 +25,7 @@
   },
   "peerDependencies": {
     "typescript": "^5.8.3",
-    "vue": "^3.5.17"
+    "vue": "^3.5"
   },
   "keywords": [
     "vue",