snap-dnd 0.1.3 → 0.2.0

package/dist/utils/DataTransfer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Custom DataTransfer implementation for passing data during drag operations
+ * Not the browser's native DataTransfer
+ */
+import type { DataTransfer as IDataTransfer } from '../types/index.js';
+export declare class SnapDataTransfer implements IDataTransfer {
+    private _data;
+    /**
+     * Set data for a given type
+     */
+    setData(type: string, value: unknown): void;
+    /**
+     * Get data for a given type
+     */
+    getData<T = unknown>(type: string): T | undefined;
+    /**
+     * Check if a type exists
+     */
+    hasType(type: string): boolean;
+    /**
+     * Get all registered types
+     */
+    get types(): string[];
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Create a copy of this transfer
+     */
+    clone(): SnapDataTransfer;
+}

package/dist/utils/EventEmitter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Lightweight pub/sub event emitter
+ * Optimized for minimal allocations
+ */
+import type { Unsubscribe } from '../types/index.js';
+export type EventCallback<T = unknown> = (data: T) => void;
+export declare class EventEmitter<Events extends Record<string, unknown>> {
+    private _listeners;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof Events>(event: K, callback: EventCallback<Events[K]>): Unsubscribe;
+    /**
+     * Subscribe to an event once
+     */
+    once<K extends keyof Events>(event: K, callback: EventCallback<Events[K]>): Unsubscribe;
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    /**
+     * Remove all listeners for an event, or all listeners
+     */
+    off<K extends keyof Events>(event?: K): void;
+    /**
+     * Check if there are any listeners for an event
+     */
+    hasListeners<K extends keyof Events>(event: K): boolean;
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount<K extends keyof Events>(event: K): number;
+    /**
+     * Clear all listeners
+     */
+    destroy(): void;
+}

package/dist/utils/ObjectPool.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generic object pool for reusing frequently allocated objects
+ * Reduces GC pressure during drag operations
+ */
+export declare class ObjectPool<T> {
+    private _pool;
+    private _factory;
+    private _reset;
+    private _maxSize;
+    constructor(factory: () => T, reset: (obj: T) => void, initialSize?: number, maxSize?: number);
+    /**
+     * Get an object from the pool or create a new one
+     */
+    acquire(): T;
+    /**
+     * Return an object to the pool for reuse
+     */
+    release(obj: T): void;
+    /**
+     * Clear all pooled objects
+     */
+    clear(): void;
+    /**
+     * Current pool size
+     */
+    get size(): number;
+}
+import type { Point, Rect } from '../types/index.js';
+export declare const pointPool: ObjectPool<Point>;
+export declare const rectPool: ObjectPool<Rect>;
+/**
+ * Helper to get a point from pool with initial values
+ */
+export declare function acquirePoint(x: number, y: number): Point;
+/**
+ * Helper to get a rect from pool with initial values
+ */
+export declare function acquireRect(x: number, y: number, width: number, height: number): Rect;

package/dist/utils/RAFThrottle.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RAF-based throttling for high-frequency events
+ * Ensures only one callback per animation frame
+ */
+export declare class RAFThrottle<T> {
+    private _rafId;
+    private _pending;
+    private _callback;
+    constructor(callback: (data: T) => void);
+    /**
+     * Queue data to be processed on next animation frame
+     * Only the most recent data will be processed
+     */
+    queue(data: T): void;
+    /**
+     * Cancel any pending frame
+     */
+    cancel(): void;
+    /**
+     * Process immediately if there's pending data
+     */
+    flush(): void;
+    /**
+     * Check if there's a pending frame
+     */
+    get isPending(): boolean;
+    private _process;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create a throttled function using RAF
+ */
+export declare function rafThrottle<T extends (...args: unknown[]) => void>(fn: T): T & {
+    cancel: () => void;
+    flush: () => void;
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { ObjectPool, pointPool, rectPool, acquirePoint, acquireRect } from './ObjectPool.js';
+export { EventEmitter, type EventCallback } from './EventEmitter.js';
+export { BoundsCache, boundsCache, pointInRect, rectsIntersect, rectCenter, distance } from './BoundsCache.js';
+export { RAFThrottle, rafThrottle } from './RAFThrottle.js';
+export { SnapDataTransfer } from './DataTransfer.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snap-dnd",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "A zero-dependency, memory-optimized drag and drop library for vanilla JS and Web Components",
   "type": "module",
   "main": "./dist/snap.umd.js",
@@ -16,8 +16,7 @@
     }
   },
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts"
+    "dist"
   ],
   "sideEffects": false,
   "scripts": {