@bquery/bquery 1.6.0 → 1.8.1

package/dist/devtools/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Public types for the bQuery DevTools module.
+ *
+ * @module bquery/devtools
+ */
+/**
+ * Snapshot of a signal's current state for the inspector.
+ */
+export interface SignalSnapshot {
+    /** Debug label (if provided). */
+    readonly label: string;
+    /** Current value of the signal. */
+    readonly value: unknown;
+    /** Number of active subscribers. */
+    readonly subscriberCount: number;
+}
+/**
+ * Snapshot of a store for the inspector.
+ */
+export interface StoreSnapshot {
+    /** Store identifier. */
+    readonly id: string;
+    /** Current state (shallow clone). */
+    readonly state: Record<string, unknown>;
+}
+/**
+ * Snapshot of a registered bQuery component.
+ */
+export interface ComponentSnapshot {
+    /** Custom element tag name. */
+    readonly tagName: string;
+    /** Number of live instances found in the DOM. */
+    readonly instanceCount: number;
+}
+/** The type of event recorded in the timeline. */
+export type TimelineEventType = 'signal:update' | 'effect:run' | 'store:patch' | 'store:action' | 'route:change';
+/**
+ * A single timeline entry.
+ */
+export interface TimelineEntry {
+    /** Timestamp (ms since epoch). */
+    readonly timestamp: number;
+    /** Event type. */
+    readonly type: TimelineEventType;
+    /** Human-readable description. */
+    readonly detail: string;
+}
+/**
+ * Options for {@link enableDevtools}.
+ */
+export interface DevtoolsOptions {
+    /**
+     * Whether to log timeline events to the console.
+     * @default false
+     */
+    logToConsole?: boolean;
+}
+/**
+ * The public devtools state object exposed by {@link getDevtoolsState}.
+ */
+export interface DevtoolsState {
+    /** `true` when devtools are active. */
+    readonly enabled: boolean;
+    /** Options passed when devtools were enabled. */
+    readonly options: Readonly<DevtoolsOptions>;
+    /** Timeline entries recorded so far. */
+    readonly timeline: readonly TimelineEntry[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/devtools/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/devtools/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,oCAAoC;IACpC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAMD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAMD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAMD,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GACzB,eAAe,GACf,YAAY,GACZ,aAAa,GACb,cAAc,GACd,cAAc,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kBAAkB;IAClB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAMD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC5C,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;CAC7C"}

package/dist/devtools-BhB2iDPT.js

@@ -0,0 +1,122 @@
+import { i as u, n as m } from "./registry-B08iilIh.js";
+var a = !1, i = {}, s = [], l = /* @__PURE__ */ new Map(), c = 0, b = (e, t) => {
+  a = e, i = t ?? {}, e || (s.length = 0, l.clear(), c = 0);
+}, S = () => a, h = (e, t, n) => {
+  if (a) {
+    if (typeof e != "string" || e.length === 0) throw new Error("bQuery devtools: trackSignal() requires a non-empty label");
+    l.set(e, {
+      peek: t,
+      subscriberCount: n
+    });
+  }
+}, y = (e) => {
+  l.delete(e);
+}, q = () => `signal_${c++}`, v = () => {
+  const e = [];
+  for (const [t, n] of l) e.push({
+    label: t,
+    value: n.peek(),
+    subscriberCount: n.subscriberCount()
+  });
+  return e;
+}, f = () => {
+  try {
+    return u().map((e) => {
+      const t = m(e), n = {};
+      if (t && typeof t == "object" && "$state" in t) {
+        const o = t.$state;
+        o && typeof o == "object" && Object.assign(n, o);
+      }
+      return {
+        id: e,
+        state: n
+      };
+    });
+  } catch {
+    return [];
+  }
+}, p = () => {
+  if (typeof document > "u") return [];
+  const e = [], t = /* @__PURE__ */ new Set(), n = document.querySelectorAll("*");
+  for (let o = 0; o < n.length; o++) {
+    const r = n[o].tagName.toLowerCase();
+    if (r.includes("-") && !t.has(r) && typeof customElements < "u" && customElements.get(r)) {
+      t.add(r);
+      const g = document.querySelectorAll(r);
+      e.push({
+        tagName: r,
+        instanceCount: g.length
+      });
+    }
+  }
+  return e;
+}, w = (e, t) => {
+  if (!a) return;
+  const n = {
+    timestamp: Date.now(),
+    type: e,
+    detail: t
+  };
+  s.push(n), i.logToConsole && console.log(`[bq:devtools] ${e} — ${t}`);
+}, C = () => s, k = () => {
+  s.length = 0;
+}, N = () => ({
+  enabled: a,
+  options: { ...i },
+  timeline: [...s]
+}), _ = () => {
+  const e = v();
+  if (e.length === 0) {
+    console.log("[bq:devtools] No tracked signals.");
+    return;
+  }
+  console.table(e);
+}, D = () => {
+  const e = f();
+  if (e.length === 0) {
+    console.log("[bq:devtools] No stores registered.");
+    return;
+  }
+  console.table(e.map((t) => ({
+    id: t.id,
+    state: JSON.stringify(t.state)
+  })));
+}, E = () => {
+  const e = p();
+  if (e.length === 0) {
+    console.log("[bq:devtools] No custom elements found.");
+    return;
+  }
+  console.table(e);
+}, T = (e) => {
+  const t = typeof e == "number" && e > 0 ? s.slice(-e) : s;
+  if (t.length === 0) {
+    console.log("[bq:devtools] Timeline is empty.");
+    return;
+  }
+  console.table(t.map((n) => ({
+    time: new Date(n.timestamp).toISOString(),
+    type: n.type,
+    detail: n.detail
+  })));
+};
+export {
+  C as a,
+  f as c,
+  _ as d,
+  D as f,
+  y as g,
+  h,
+  N as i,
+  S as l,
+  w as m,
+  b as n,
+  p as o,
+  T as p,
+  q as r,
+  v as s,
+  k as t,
+  E as u
+};
+
+//# sourceMappingURL=devtools-BhB2iDPT.js.map

package/dist/devtools-BhB2iDPT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools-BhB2iDPT.js","names":[],"sources":["../src/devtools/devtools.ts"],"sourcesContent":["/**\n * bQuery DevTools — runtime debugging utilities.\n *\n * Enable devtools to inspect signals, stores, components, and view a\n * timeline of reactive events.\n *\n * @module bquery/devtools\n */\n\nimport type {\n  ComponentSnapshot,\n  DevtoolsOptions,\n  DevtoolsState,\n  SignalSnapshot,\n  StoreSnapshot,\n  TimelineEntry,\n  TimelineEventType,\n} from './types';\nimport { listStores as _listStores, getStore as _getStore } from '../store/registry';\n\n// ---------------------------------------------------------------------------\n// Internal state\n// ---------------------------------------------------------------------------\n\nlet _enabled = false;\nlet _options: DevtoolsOptions = {};\nconst _timeline: TimelineEntry[] = [];\n\n/** Registered signals keyed by label. */\nconst _trackedSignals = new Map<string, { peek: () => unknown; subscriberCount: () => number }>();\n\n/** Monotonic counter for auto-labelling anonymous signals. */\nlet _signalCounter = 0;\n\n// ---------------------------------------------------------------------------\n// Enable / disable\n// ---------------------------------------------------------------------------\n\n/**\n * Enable bQuery development mode.\n *\n * When enabled the devtools module records timeline events and\n * allows inspection of signals, stores, and components.\n *\n * @param enabled - `true` to enable, `false` to disable.\n * @param options - Optional configuration.\n *\n * @example\n * ```ts\n * import { enableDevtools } from '@bquery/bquery/devtools';\n * enableDevtools(true, { logToConsole: true });\n * ```\n */\nexport const enableDevtools = (enabled: boolean, options?: DevtoolsOptions): void => {\n  _enabled = enabled;\n  _options = options ?? {};\n\n  if (!enabled) {\n    _timeline.length = 0;\n    _trackedSignals.clear();\n    _signalCounter = 0;\n  }\n};\n\n/**\n * Returns `true` when devtools are active.\n *\n * @example\n * ```ts\n * import { isDevtoolsEnabled } from '@bquery/bquery/devtools';\n * if (isDevtoolsEnabled()) { ... }\n * ```\n */\nexport const isDevtoolsEnabled = (): boolean => _enabled;\n\n// ---------------------------------------------------------------------------\n// Signal tracking\n// ---------------------------------------------------------------------------\n\n/**\n * Register a signal for devtools inspection.\n *\n * @param label - Human-readable label (must be unique).\n * @param peek - Returns the signal's value without tracking.\n * @param subscriberCount - Returns the current subscriber count.\n * @throws If a signal with the same label is already tracked.\n *\n * @example\n * ```ts\n * import { trackSignal } from '@bquery/bquery/devtools';\n * import { signal } from '@bquery/bquery/reactive';\n *\n * const count = signal(0);\n * trackSignal('count', () => count.peek(), () => 0);\n * ```\n */\nexport const trackSignal = (\n  label: string,\n  peek: () => unknown,\n  subscriberCount: () => number\n): void => {\n  if (!_enabled) return;\n  if (typeof label !== 'string' || label.length === 0) {\n    throw new Error('bQuery devtools: trackSignal() requires a non-empty label');\n  }\n  _trackedSignals.set(label, { peek, subscriberCount });\n};\n\n/**\n * Remove a previously tracked signal.\n *\n * @param label - The label used during registration.\n *\n * @example\n * ```ts\n * import { untrackSignal } from '@bquery/bquery/devtools';\n * untrackSignal('count');\n * ```\n */\nexport const untrackSignal = (label: string): void => {\n  _trackedSignals.delete(label);\n};\n\n/**\n * Generate a unique label for anonymous signals.\n *\n * @returns A label such as `signal_0`, `signal_1`, …\n *\n * @example\n * ```ts\n * import { generateSignalLabel } from '@bquery/bquery/devtools';\n * const label = generateSignalLabel(); // 'signal_0'\n * ```\n */\nexport const generateSignalLabel = (): string => `signal_${_signalCounter++}`;\n\n// ---------------------------------------------------------------------------\n// Signal inspector\n// ---------------------------------------------------------------------------\n\n/**\n * List all tracked signals with their current values.\n *\n * @returns An array of {@link SignalSnapshot} objects.\n *\n * @example\n * ```ts\n * import { inspectSignals } from '@bquery/bquery/devtools';\n * console.table(inspectSignals());\n * ```\n */\nexport const inspectSignals = (): SignalSnapshot[] => {\n  const result: SignalSnapshot[] = [];\n  for (const [label, entry] of _trackedSignals) {\n    result.push({\n      label,\n      value: entry.peek(),\n      subscriberCount: entry.subscriberCount(),\n    });\n  }\n  return result;\n};\n\n// ---------------------------------------------------------------------------\n// Store inspector\n// ---------------------------------------------------------------------------\n\n/**\n * List all stores with their current state.\n *\n * Reads from the store registry (`listStores` / `getStore`) that is\n * already maintained by the store module.\n *\n * @returns An array of {@link StoreSnapshot} objects.\n *\n * @example\n * ```ts\n * import { inspectStores } from '@bquery/bquery/devtools';\n * console.table(inspectStores());\n * ```\n */\nexport const inspectStores = (): StoreSnapshot[] => {\n  try {\n    const ids: string[] = _listStores();\n    return ids.map((id: string) => {\n      const store = _getStore(id) as Record<string, unknown> | undefined;\n      const state: Record<string, unknown> = {};\n      if (store && typeof store === 'object' && '$state' in store) {\n        const raw = (store as { $state: unknown }).$state;\n        if (raw && typeof raw === 'object') {\n          Object.assign(state, raw);\n        }\n      }\n      return { id, state };\n    });\n  } catch {\n    return [];\n  }\n};\n\n// ---------------------------------------------------------------------------\n// Component inspector\n// ---------------------------------------------------------------------------\n\n/**\n * List all bQuery-registered custom elements visible in the document.\n *\n * @returns An array of {@link ComponentSnapshot} objects.\n *\n * @example\n * ```ts\n * import { inspectComponents } from '@bquery/bquery/devtools';\n * console.table(inspectComponents());\n * ```\n */\nexport const inspectComponents = (): ComponentSnapshot[] => {\n  if (typeof document === 'undefined') return [];\n\n  const result: ComponentSnapshot[] = [];\n  const seen = new Set<string>();\n\n  // Walk every custom element in the DOM (they must contain a hyphen)\n  const all = document.querySelectorAll('*');\n  for (let i = 0; i < all.length; i++) {\n    const el = all[i];\n    const tag = el.tagName.toLowerCase();\n    if (!tag.includes('-')) continue;\n    if (seen.has(tag)) continue;\n\n    // Only include if registered via customElements\n    if (typeof customElements !== 'undefined' && customElements.get(tag)) {\n      seen.add(tag);\n      const instances = document.querySelectorAll(tag);\n      result.push({ tagName: tag, instanceCount: instances.length });\n    }\n  }\n  return result;\n};\n\n// ---------------------------------------------------------------------------\n// Timeline\n// ---------------------------------------------------------------------------\n\n/**\n * Record a timeline event.\n *\n * This is called internally by bQuery modules (signals, store, router)\n * or can be called from user code / plugins to add custom entries.\n *\n * @param type - The event category.\n * @param detail - A human-readable description.\n *\n * @example\n * ```ts\n * import { recordEvent } from '@bquery/bquery/devtools';\n * recordEvent('signal:update', 'count changed to 5');\n * ```\n */\nexport const recordEvent = (type: TimelineEventType, detail: string): void => {\n  if (!_enabled) return;\n\n  const entry: TimelineEntry = {\n    timestamp: Date.now(),\n    type,\n    detail,\n  };\n  _timeline.push(entry);\n\n  if (_options.logToConsole) {\n    console.log(`[bq:devtools] ${type} — ${detail}`);\n  }\n};\n\n/**\n * Returns the full timeline log.\n *\n * @returns A read-only array of {@link TimelineEntry} objects.\n *\n * @example\n * ```ts\n * import { getTimeline } from '@bquery/bquery/devtools';\n * for (const e of getTimeline()) {\n *   console.log(e.type, e.detail);\n * }\n * ```\n */\nexport const getTimeline = (): readonly TimelineEntry[] => _timeline;\n\n/**\n * Clear all timeline entries.\n *\n * @example\n * ```ts\n * import { clearTimeline } from '@bquery/bquery/devtools';\n * clearTimeline();\n * ```\n */\nexport const clearTimeline = (): void => {\n  _timeline.length = 0;\n};\n\n// ---------------------------------------------------------------------------\n// Combined state\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a snapshot of the full devtools state.\n *\n * @returns A {@link DevtoolsState} object.\n *\n * @example\n * ```ts\n * import { getDevtoolsState } from '@bquery/bquery/devtools';\n * const state = getDevtoolsState();\n * console.log(state.enabled, state.timeline.length);\n * ```\n */\nexport const getDevtoolsState = (): DevtoolsState => ({\n  enabled: _enabled,\n  options: { ..._options },\n  timeline: [..._timeline],\n});\n\n// ---------------------------------------------------------------------------\n// Log helpers (convenience for interactive debugging)\n// ---------------------------------------------------------------------------\n\n/**\n * Pretty-print all tracked signals to the console.\n *\n * @example\n * ```ts\n * import { logSignals } from '@bquery/bquery/devtools';\n * logSignals(); // → table output\n * ```\n */\nexport const logSignals = (): void => {\n  const signals = inspectSignals();\n  if (signals.length === 0) {\n    console.log('[bq:devtools] No tracked signals.');\n    return;\n  }\n\n  console.table(signals);\n};\n\n/**\n * Pretty-print all stores to the console.\n *\n * @example\n * ```ts\n * import { logStores } from '@bquery/bquery/devtools';\n * logStores(); // → table output\n * ```\n */\nexport const logStores = (): void => {\n  const stores = inspectStores();\n  if (stores.length === 0) {\n    console.log('[bq:devtools] No stores registered.');\n    return;\n  }\n\n  console.table(stores.map((s) => ({ id: s.id, state: JSON.stringify(s.state) })));\n};\n\n/**\n * Pretty-print all registered components to the console.\n *\n * @example\n * ```ts\n * import { logComponents } from '@bquery/bquery/devtools';\n * logComponents(); // → table output\n * ```\n */\nexport const logComponents = (): void => {\n  const components = inspectComponents();\n  if (components.length === 0) {\n    console.log('[bq:devtools] No custom elements found.');\n    return;\n  }\n\n  console.table(components);\n};\n\n/**\n * Pretty-print the timeline to the console.\n *\n * @param last - Only show the last N entries (default: all).\n *\n * @example\n * ```ts\n * import { logTimeline } from '@bquery/bquery/devtools';\n * logTimeline(10);\n * ```\n */\nexport const logTimeline = (last?: number): void => {\n  const entries = typeof last === 'number' && last > 0 ? _timeline.slice(-last) : _timeline;\n  if (entries.length === 0) {\n    console.log('[bq:devtools] Timeline is empty.');\n    return;\n  }\n\n  console.table(\n    entries.map((e) => ({\n      time: new Date(e.timestamp).toISOString(),\n      type: e.type,\n      detail: e.detail,\n    }))\n  );\n};\n"],"mappings":"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"}

package/dist/devtools.es.mjs

@@ -0,0 +1,19 @@
+import { a as e, c as s, d as n, f as o, g as t, h as l, i, l as g, m as r, n as c, o as m, p, r as S, s as v, t as b, u as d } from "./devtools-BhB2iDPT.js";
+export {
+  b as clearTimeline,
+  c as enableDevtools,
+  S as generateSignalLabel,
+  i as getDevtoolsState,
+  e as getTimeline,
+  m as inspectComponents,
+  v as inspectSignals,
+  s as inspectStores,
+  g as isDevtoolsEnabled,
+  d as logComponents,
+  n as logSignals,
+  o as logStores,
+  p as logTimeline,
+  r as recordEvent,
+  l as trackSignal,
+  t as untrackSignal
+};

package/dist/dnd/draggable.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Make an element draggable using pointer events.
+ *
+ * Uses Pointer Events (not HTML5 Drag & Drop) for reliable
+ * cross-platform behavior including touch support.
+ *
+ * @module bquery/dnd
+ */
+import type { DragPosition, DraggableHandle, DraggableOptions } from './types';
+/**
+ * Returns the currently active drag state, if any.
+ * Used internally by `droppable()` to detect drag interactions.
+ * @internal
+ */
+export declare const getActiveDrag: () => {
+    element: HTMLElement;
+    position: DragPosition;
+} | undefined;
+/**
+ * Makes an element draggable using pointer events.
+ *
+ * Features:
+ * - Touch and mouse support via Pointer Events
+ * - Axis locking (`x`, `y`, or `both`)
+ * - Bounds constraint (parent, selector, or explicit rect)
+ * - Optional drag handle
+ * - Ghost/clone preview during drag
+ * - Callbacks: `onDragStart`, `onDrag`, `onDragEnd`
+ *
+ * @param el - The element to make draggable
+ * @param options - Configuration options
+ * @returns A handle with `destroy()`, `disable()`, and `enable()` methods
+ *
+ * @example
+ * ```ts
+ * import { draggable } from '@bquery/bquery/dnd';
+ *
+ * const handle = draggable(document.querySelector('#box'), {
+ *   axis: 'both',
+ *   bounds: 'parent',
+ *   onDragEnd: ({ position }) => {
+ *     console.log('Dropped at', position.x, position.y);
+ *   },
+ * });
+ *
+ * // Later:
+ * handle.destroy();
+ * ```
+ */
+export declare const draggable: (el: HTMLElement, options?: DraggableOptions) => DraggableHandle;
+//# sourceMappingURL=draggable.d.ts.map

package/dist/dnd/draggable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draggable.d.ts","sourceRoot":"","sources":["../../src/dnd/draggable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAIV,YAAY,EACZ,eAAe,EACf,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAKjB;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAAO;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GAAG,SAGnF,CAAC;AAgDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,WAAW,EAAE,UAAS,gBAAqB,KAAG,eA2L3E,CAAC"}

package/dist/dnd/droppable.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Define drop zones for draggable elements.
+ *
+ * Drop zones detect when draggable elements enter, move over,
+ * leave, or are dropped onto them using pointer event hit-testing.
+ *
+ * @module bquery/dnd
+ */
+import type { DroppableHandle, DroppableOptions } from './types';
+/**
+ * Defines an element as a drop zone.
+ *
+ * Drop zones respond to draggable elements being moved over them
+ * by firing callbacks and applying CSS classes. They work with
+ * the `draggable()` function from this module.
+ *
+ * @param el - The drop zone element
+ * @param options - Configuration options
+ * @returns A handle with a `destroy()` method
+ *
+ * @example
+ * ```ts
+ * import { droppable } from '@bquery/bquery/dnd';
+ *
+ * const handle = droppable(document.querySelector('#dropzone'), {
+ *   accept: '.draggable-item',
+ *   overClass: 'drop-active',
+ *   onDrop: ({ dragged }) => {
+ *     console.log('Dropped:', dragged);
+ *   },
+ * });
+ *
+ * // Later:
+ * handle.destroy();
+ * ```
+ */
+export declare const droppable: (el: HTMLElement, options?: DroppableOptions) => DroppableHandle;
+//# sourceMappingURL=droppable.d.ts.map

package/dist/dnd/droppable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"droppable.d.ts","sourceRoot":"","sources":["../../src/dnd/droppable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAiB,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA+FhF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,WAAW,EAAE,UAAS,gBAAqB,KAAG,eA+F3E,CAAC"}

package/dist/dnd/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * bQuery Drag & Drop module.
+ *
+ * Provides pointer-event-based drag-and-drop, drop zones, and sortable
+ * lists with built-in touch support, axis locking, bounds constraints,
+ * and animated reordering.
+ *
+ * @module bquery/dnd
+ *
+ * @example
+ * ```ts
+ * import { draggable, droppable, sortable } from '@bquery/bquery/dnd';
+ *
+ * // Make an element draggable
+ * const drag = draggable(document.querySelector('#box'), {
+ *   axis: 'both',
+ *   bounds: 'parent',
+ *   ghost: true,
+ *   onDragEnd: ({ position }) => console.log(position),
+ * });
+ *
+ * // Define a drop zone
+ * const drop = droppable(document.querySelector('#zone'), {
+ *   accept: '.draggable',
+ *   onDrop: ({ dragged }) => console.log('Dropped!', dragged),
+ * });
+ *
+ * // Make a list sortable
+ * const sort = sortable(document.querySelector('#list'), {
+ *   items: 'li',
+ *   axis: 'y',
+ *   onSortEnd: ({ oldIndex, newIndex }) => {
+ *     console.log(`Moved from ${oldIndex} to ${newIndex}`);
+ *   },
+ * });
+ *
+ * // Cleanup when done
+ * drag.destroy();
+ * drop.destroy();
+ * sort.destroy();
+ * ```
+ */
+export { draggable } from './draggable';
+export { droppable } from './droppable';
+export { sortable } from './sortable';
+export type { BoundsRect, DragAxis, DragBounds, DragEventData, DragPosition, DraggableHandle, DraggableOptions, DropEventData, DroppableHandle, DroppableOptions, SortEventData, SortableHandle, SortableOptions, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/dnd/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dnd/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,YAAY,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,eAAe,GAChB,MAAM,SAAS,CAAC"}

package/dist/dnd/sortable.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Sortable list with animated reordering via pointer events.
+ *
+ * Makes children of a container sortable by dragging. Items are
+ * rearranged in the DOM with optional CSS animation.
+ *
+ * @module bquery/dnd
+ */
+import type { SortableHandle, SortableOptions } from './types';
+/**
+ * Makes the children of a container sortable by dragging.
+ *
+ * Features:
+ * - Pointer event based (touch + mouse)
+ * - Animated reordering with configurable duration
+ * - Axis constraint (vertical or horizontal)
+ * - Optional drag handle
+ * - Placeholder element during sort
+ * - Callbacks: `onSortStart`, `onSortMove`, `onSortEnd`
+ *
+ * @param container - The container element whose children will be sortable
+ * @param options - Configuration options
+ * @returns A handle with `destroy()`, `disable()`, and `enable()` methods
+ *
+ * @example
+ * ```ts
+ * import { sortable } from '@bquery/bquery/dnd';
+ *
+ * const handle = sortable(document.querySelector('#list'), {
+ *   items: 'li',
+ *   axis: 'y',
+ *   animationDuration: 200,
+ *   onSortEnd: ({ oldIndex, newIndex }) => {
+ *     console.log(`Moved from ${oldIndex} to ${newIndex}`);
+ *   },
+ * });
+ *
+ * // Later:
+ * handle.destroy();
+ * ```
+ */
+export declare const sortable: (container: HTMLElement, options?: SortableOptions) => SortableHandle;
+//# sourceMappingURL=sortable.d.ts.map

package/dist/dnd/sortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortable.d.ts","sourceRoot":"","sources":["../../src/dnd/sortable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAiB,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA6C9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,QAAQ,GAAI,WAAW,WAAW,EAAE,UAAS,eAAoB,KAAG,cA4NhF,CAAC"}